AISEA Logo

YOINK.MD

Your gateway to the frontier of AI

Latest issue/ISSUE 001

Oct 18 – Oct 21

YOINK.MD · Oct 18 – Oct 21

This week, we've seen a surge in research focused on agent capabilities and their applications, with eight papers exploring everything from dexterous manipulation to self-building labs. In the realm of vision,…

DataInfraAgentsVision
Read digest →
001
issue-001.md
> papers: 15
> topics: Data, Infra, Agents, Vision
> for: builders in SEA

Past issues

What's worth reading today.

AI research papers scored by an LLM eval pipeline on novelty and reliability. Upvote to surface what the community should discuss.

PDF preview for Causal Chain of Thought: Mitigating Attention Leakage via Context Isolation
PASS ✓

Causal Chain of Thought: Mitigating Attention Leakage via Context Isolation

2026.10.22reasoning

Gabriele Dominici, Teague McMillan, Fazl Barez, et al.

Imagine you're developing an AI that needs to explain its decisions clearly, like a virtual assistant helping users with complex tasks. Current models often generate answers that sound plausible but lack true reasoning, leading to what's called 'post-hoc justifications' — where the model provides explanations that don't actually reflect how it arrived at its answer. This can result in misleading outputs, especially when the model relies on global context rather than focusing on the specific reasoning steps that matter. To address this, CausalCoT introduces a framework that breaks down problems into a directed acyclic graph of smaller, atomic questions. Each question is evaluated in isolation, considering only its direct causal relationships, which helps ensure that the reasoning process is transparent and grounded in the actual logic of the problem. This approach not only maintains competitive predictive performance but also significantly improves the faithfulness of explanations, making the reasoning steps more reliable. For builders, this means you can create AI systems that not only perform well but also provide clearer, more trustworthy rationales for their decisions.

Novelty
8.5
Reliability
8.0
arxiv/2610.31639 →
PDF preview for PhysiCalWorld: In-Context Physics Calibration for World Models
PASS ✓

PhysiCalWorld: In-Context Physics Calibration for World Models

2026.10.21agentscode

Yunhao Luo, Wentao He, Yinpei Dai, et al.

Imagine you're developing a robot that needs to navigate and interact with various environments, like a home or a factory. The challenge is that traditional models often rely on limited visual input or short histories, which can lead to inaccurate predictions about how objects behave. This can result in issues like the robot misjudging how far to reach or how much force to apply, a problem known as model drift. Without understanding the underlying physics, such as an object's weight or friction, the robot's actions can become unreliable in new situations. To address this, the authors propose a method called PhysiCalWorld, which allows the robot to learn about the specific dynamics of its environment through short interaction clips. Instead of needing extensive physics knowledge or fine-tuning, this method creates a compact descriptor that captures the essential physical properties of the scene. This descriptor can then be reused, making the robot's predictions more accurate and reliable across different tasks. Compared to previous approaches, PhysiCalWorld not only improves prediction accuracy but also creates a structured latent space that generalizes well, meaning it can adapt to new scenarios without extensive retraining.

Novelty
8.5
Reliability
7.5
arxiv/2610.30125 →
PDF preview for Environment Duels: A Microcosm of LLM Co-Evolution
PASS ✓

Environment Duels: A Microcosm of LLM Co-Evolution

2026.10.21agentscode

Shibo Jin, Zhiqiu Xu, Yiling Zou, et al.

Imagine you're developing a large language model (LLM) that needs to not only answer questions but also create complex environments for others to solve. Traditional benchmarks often focus on isolated tasks, which can overlook how models interact and learn from each other in real-world scenarios. This can lead to issues like models failing to adapt or not leveraging hints effectively, which is what's called a lack of agentic behavior. These shortcomings highlight the need for a more nuanced evaluation of LLM capabilities in collaborative settings. To address this, Environment Duels introduces a benchmark where models compete by creating and solving tasks in interactive environments. Each model writes environments with hints that can significantly aid or hinder performance, revealing distinct skills in authorship and problem-solving. The findings show that smaller models can excel in crafting challenging tasks and hints, while larger models may not always be the best at both roles. This approach not only assesses individual capabilities but also captures how models influence each other, providing insights into their collaborative dynamics. Compared to previous work, this method emphasizes the importance of interaction and learning in LLMs, offering a more comprehensive framework for evaluating their performance in real-world applications. For builders, this means a better understanding of how to design models that can effectively learn from and adapt to their environments.

Novelty
8.5
Reliability
7.5
arxiv/2610.30116 →
PDF preview for The End of Consensus Research?
PASS ✓

The End of Consensus Research?

2026.10.21infra

Clément Burgelin, Rachid Guerraoui, Zicong Hong, et al.

Imagine you're building a distributed system that needs to agree on the state of data across multiple locations, like a geo-replicated database. The challenge is that existing consensus protocols often struggle with latency, especially under heavy workloads, leading to delays and inefficiencies. This is what's called the consensus problem, and it can become a bottleneck when trying to ensure that all parts of your system are synchronized and responsive. Current solutions can be slow and cumbersome, particularly when the system is under stress from many simultaneous reads and writes. This can result in increased latency and reduced performance, which is critical for applications that require real-time data access. To address these issues, the authors propose A-greement, a new consensus protocol that leverages AI to enhance the discovery and implementation of efficient consensus strategies. The intuition behind A-greement is to combine various techniques, such as lease-authorized local reads and direct client learning, to optimize how data is written and read across distributed systems. By intelligently selecting the best approach based on network conditions and workload types, A-greement achieves significant reductions in latency—12.2% for write-heavy and 33.3% for read-heavy workloads compared to existing solutions. This means that for builders, adopting A-greement could lead to faster and more reliable distributed systems, ultimately improving user experience and system efficiency.

Novelty
8.5
Reliability
8.0
arxiv/2610.30114 →
PDF preview for Asymmetric On-Policy Distillation Learns In-Context Exploration
PASS ✓

Asymmetric On-Policy Distillation Learns In-Context Exploration

2026.10.21agentscode

Sriyash Poddar, Yanda Bao, Jacob Krantz, et al.

Imagine you're developing an AI agent that needs to navigate a complex environment, like a robot exploring a room to find objects. The challenge is that the agent often doesn't have complete information about its surroundings, making it hard to decide where to go next. Traditional methods, like reinforcement learning, require a lot of trial and error to learn effective exploration strategies, which can be very inefficient and time-consuming. This is what's called sample inefficiency, where the agent struggles to gather enough information before it can act effectively. On the other hand, offline imitation learning can average expert actions but fails to teach the agent how to explore when it doesn't know what to do next. This leads to a lack of adaptability in uncertain situations. To address these issues, ASTEROID proposes a student-teacher framework where a student agent learns to explore by conditioning its actions on its own history of interactions, guided by a privileged expert. The expert provides action labels based on the student's context, allowing the student to learn how to gather information effectively while navigating uncertainty. This method significantly reduces the number of interactions needed compared to traditional reinforcement learning, achieving better performance in exploration tasks across various environments. For builders, this means you can develop agents that are not only more efficient in learning but also more capable of handling real-world scenarios where information is incomplete, ultimately leading to better performance in practical applications.

Novelty
8.5
Reliability
8.0
arxiv/2610.30105 →
PDF preview for Did the Problem Actually Get Harder? Testing LLMs on Paired P and NP-Complete Problems Hardened by Adversarial Multi-Agent Rewriting
PASS ✓

Did the Problem Actually Get Harder? Testing LLMs on Paired P and NP-Complete Problems Hardened by Adversarial Multi-Agent Rewriting

2026.10.21reasoningcode

Nurul Labib Sayeedi, Md. Faiyaz Abdullah Sayeedi, Zabir Al Nazi, et al.

Imagine you're developing an AI that needs to solve complex problems, like figuring out the best way to color a graph. The challenge is that many problems are NP-complete, meaning they can be very hard to solve, while others have easier polynomial-time counterparts. Current benchmarks often present these problems in a fixed way, which can lead to models simply recalling answers rather than genuinely reasoning through the problem. This is what's called a lack of complexity awareness, where models struggle to differentiate between the two types of problems due to familiar phrasing or cues. To address this, the authors created P2NPCBench, a benchmark that pairs NP-complete problems with their polynomial-time twins, ensuring that the phrasing is challenging enough to prevent simple recall. They used an adversarial framework called AgentGAN to generate 2,114 unique problem statements that maintain the integrity of the problem while removing textbook cues. The results showed that models performed significantly worse on NP-complete problems compared to their polynomial-time counterparts, highlighting the need for better reasoning capabilities in AI. This benchmark not only provides a more accurate assessment of model performance but also emphasizes the importance of understanding problem complexity in AI development.

Novelty
8.5
Reliability
8.0
arxiv/2610.30103 →
PDF preview for Joints, Camera, Action! Co-Generating 3D Motion and Video for Arbitrary Rigs
PASS ✓

Joints, Camera, Action! Co-Generating 3D Motion and Video for Arbitrary Rigs

2026.10.20vision

Noam Rotstein, Yoad Tewel, Chen Tessler, et al.

Imagine you're creating a video game where characters need to perform realistic movements, like a monkey jumping over a crossbar. Current models can generate impressive videos, but they struggle to translate those movements into usable 3D animations that can be replayed in a game engine. This limitation often leads to either overly complex models that only work with human skeletons or methods that rely on converting 2D poses into 3D motion, which can be inaccurate and cumbersome. This is what's called the 'motion capture problem.' To address this, the authors propose a model that generates both video and 3D motion simultaneously, allowing for any type of character rig. By keeping the 3D motion generation separate from the video generation, the model can learn how different skeletons move using motion data alone, which is easier to gather than paired video data. This separation also enables the model to accurately locate joints in video frames, facilitating the integration of 3D motion into the scene. Compared to previous methods, this approach allows for more faithful animations from text prompts and better responsiveness to the surrounding environment, making it a significant step forward for developers looking to create dynamic and interactive animations.

Novelty
8.5
Reliability
7.5
arxiv/2610.28632 →
PDF preview for GBClaw: An agentic AI framework for atomistic grain boundary research and mechanistic discovery
PASS ✓

GBClaw: An agentic AI framework for atomistic grain boundary research and mechanistic discovery

2026.10.20agents

Yazhuo Liu, Kunqing Ding, Xiaoguo Gong, et al.

Imagine you're working on developing new materials, like alloys or ceramics, where understanding the interfaces between grains is crucial. These grain boundaries can significantly affect the material's properties, but studying them is tough due to their complex structures and the limitations of current experimental methods. Researchers often struggle with traditional approaches that either oversimplify these boundaries or fail to capture their dynamic behavior, leading to incomplete insights into how materials will perform under stress — this is what's called a lack of mechanistic understanding. To address this, the authors introduce GBClaw, a framework that leverages large language models and modular AI agents to systematically investigate grain boundaries. By integrating simulations with targeted analysis, GBClaw can dynamically adapt its approach based on ongoing findings, allowing for a more nuanced exploration of how different boundary structures respond to stress and deformation. In their study of nickel's grain boundaries, they not only identified various defect structures but also uncovered how these defects influence shear strength, revealing insights that could guide future material design. This approach bridges the gap between high-throughput computational methods and the deep physical understanding needed for effective materials discovery.

Novelty
8.5
Reliability
7.5
arxiv/2610.28629 →
PDF preview for Learning Adaptable Dexterous Skills via Hybrid Dexterous Mimicking
PASS ✓

Learning Adaptable Dexterous Skills via Hybrid Dexterous Mimicking

2026.10.20agentscode

Yuxuan Kuang, Jiashun Wang, Yixuan Sun, et al.

Imagine you're developing a robotic hand that needs to perform tasks like grasping objects or passing them smoothly between people. Current methods either rely on reinforcement learning, which can lead to awkward and unreliable movements without human guidance, or on motion tracking, which mimics human actions but lacks flexibility. This is what's called a trade-off: you can either have generalization or human-like precision, but not both. AdaDex addresses this by using a goal-conditioned reinforcement learning framework that learns from just a few seconds of human motion data. It combines two training environments: one that teaches the robot to mimic human movements and another that challenges it to adapt to new situations with varied starting points and goals. This dual approach allows the robot to develop a range of skills, from functional grasping to dynamic actions like throwing and catching. Compared to previous methods, AdaDex not only generalizes better but also transfers its skills across different simulators and into real-world applications, making it a promising tool for building more capable robotic systems.

Novelty
8.5
Reliability
7.5
arxiv/2610.28628 →
PDF preview for UniWALM: Unified World Action Language Model for Embodied Robot Control
PASS ✓

UniWALM: Unified World Action Language Model for Embodied Robot Control

2026.10.20agents

Rahul Sajnani, Diego Romeres, Mingyuan Zhang, et al.

Imagine you're developing an AI that can understand and interact with the world through both language and actions, like a robot that can pick up objects based on verbal commands. Current systems often treat language and action as separate processes, leading to issues like miscommunication or failure to adapt when unexpected situations arise. For instance, if a robot is told to 'pick up the red ball,' it might struggle if the ball is out of sight or if the command is vague, resulting in what's called a context drop or a failure to execute the task correctly. This separation can hinder the AI's ability to learn from experiences and improve over time, especially in dynamic environments where memory and adaptability are crucial.  To address these challenges, UniWALM proposes a unified model that learns from video, action, and language simultaneously. By integrating these modalities into a single framework, it allows the AI to generate language as it performs actions, effectively using language as a form of memory. This means that when the AI encounters a new situation, it can refer back to its generated language to inform its next steps, creating a feedback loop that enhances learning and decision-making. The results show that UniWALM outperforms existing models in tasks requiring memory and adaptability, significantly improving success rates in real-world scenarios. For builders, this means a more robust foundation for developing AI systems that can operate effectively in complex, real-world environments.

Novelty
8.5
Reliability
7.5
arxiv/2610.28626 →
PDF preview for Planning under Noise with Neural Operators
PASS ✓

Planning under Noise with Neural Operators

2026.10.20agents

Michael Chen, Hong Chul Nam, Xi Deng, et al.

Imagine you're designing a robot that needs to navigate through a cluttered space, but the environment is unpredictable — obstacles might shift, and the robot's movements can be noisy. Traditional planning methods often struggle in these scenarios because they rely on fixed paths and can easily get stuck or misled by noise, which is what's called planning failure. When the robot encounters an obstacle, it might not know how to adjust its route effectively, leading to inefficient navigation or even complete failure to reach its goal. This is particularly problematic in complex environments where the layout can change unexpectedly. To address these challenges, the authors propose a method called Planning Under Noise (PUN), which learns to create noise-aware value fields that help the robot plan its path more effectively. Instead of getting stuck at obstacles, PUN uses a clever approach to allow paths to explore freely until they reach the target, even in the presence of noise. By leveraging a Monte Carlo solver that learns from noisy data, PUN can efficiently compute paths without needing extensive recalibration for every new scenario. In tests, PUN outperformed existing planners in terms of success rates and speed, particularly in high-noise situations, making it a promising tool for anyone building navigation systems in unpredictable environments.

Novelty
8.0
Reliability
7.5
arxiv/2610.28623 →
PDF preview for Adaptive Multi-Token Prediction: How far should we go?
PASS ✓

Adaptive Multi-Token Prediction: How far should we go?

2026.10.20infra

Emile Anand, Mohammed Rehan Parwani, Xinyuan Cao

Imagine you're building a language model that needs to generate text quickly and accurately, like drafting responses in a chat application. Currently, models generate one token at a time, which can be slow and inefficient, especially when the context changes. This method can lead to wasted computation if the model drafts too many tokens that are ultimately rejected, a situation known as inefficiency in token prediction. The challenge is to decide how many tokens to draft at once without knowing in advance how many will be accepted. This is where Adaptive Multi-Token Prediction (AMTP) comes in. It acts like a smart controller that learns from past experiences to determine the optimal number of tokens to draft based on the context, maximizing the speed of decoding while minimizing wasted effort. By predicting how many tokens are likely to be accepted, AMTP can adjust its strategy dynamically, leading to faster overall performance. Compared to traditional methods, AMTP can decode up to 4.1 times faster and achieves better throughput in most scenarios, making it a valuable tool for anyone looking to enhance the efficiency of language model applications.

Novelty
8.0
Reliability
7.5
arxiv/2610.28619 →
PDF preview for Semantic Observability for Autonomous Systems Diagnostics
PASS ✓

Semantic Observability for Autonomous Systems Diagnostics

2026.10.20agents

Jitendra Solanki, Anand Todkar, Ziran Min

Imagine you're a Site Reliability Engineer (SRE) trying to troubleshoot a cascading failure in a complex microservice architecture. You’re faced with a flood of logs from various services, each formatted differently, making it hard to pinpoint the root cause. Currently, you might sift through these logs manually, using keyword searches and checking multiple dashboards, which is time-consuming and often leads to missed correlations. This process can be frustrating and inefficient, especially when you need to act quickly to resolve issues — this is what's called the 'Mean Time to Resolution' (MTTR) problem. To address this, the authors propose a framework called Semantic Observability, which integrates disparate log streams into a unified Property Graph Database. This system models the infrastructure and software dependencies as a graph, allowing for better navigation and analysis of events. By employing a multi-agent system that uses causal graph algorithms, it can autonomously identify the scope of anomalies and generate actionable insights through a Large Language Model (LLM). This approach not only reduces noise from irrelevant telemetry but also enhances the accuracy of root cause analyses, ultimately leading to faster resolutions. Compared to traditional methods, this framework offers a more structured and efficient way to manage observability data, making it a valuable tool for engineers in production environments.

Novelty
8.0
Reliability
7.5
arxiv/2610.28611 →
PDF preview for Value-Rich, Differently Organized: Measuring Value Expression and Organization in AI-Generated Debates
PASS ✓

Value-Rich, Differently Organized: Measuring Value Expression and Organization in AI-Generated Debates

2026.10.20reasoningcode

Maoyuan Li, Haoyuan Li, Zhongsheng Wang, et al.

Imagine you're developing an AI that can engage in debates, helping users explore different viewpoints. While current evaluations focus on how well arguments are made, they often overlook how values are expressed and structured within those arguments. This can lead to a misunderstanding of the debate's depth and the effectiveness of the AI's reasoning. For instance, an AI might generate arguments that touch on many values but fail to organize them coherently, which can confuse the audience or dilute the message. This is what's called value organization failure, where the presence of values doesn't translate into effective communication. To address this, the authors propose a framework that assesses both how values are expressed and how they are organized throughout a debate. Grounded in Schwartz's Basic-10 value theory, this framework allows for a nuanced analysis of debates by breaking down value expression and organization into measurable components. The results indicate that while AI-generated debates can invoke a wide range of values, they often lack clarity in how these values are presented across different turns. This insight suggests that for anyone building debate systems, it's crucial to not only ensure a variety of values are represented but also to focus on how these values are structured to enhance clarity and impact.

Novelty
8.0
Reliability
7.5
arxiv/2610.28604 →
PDF preview for Evolving Agent Interfaces
PASS ✓

Evolving Agent Interfaces

2026.10.20agentscode

Saaket Agashe, Yuzhe Yang, Gonzalo Gonzalez-Pumariega, et al.

Imagine you're trying to build an AI that can help users navigate complex software tasks, like managing spreadsheets or searching through code. Currently, agents often rely on rigid interfaces that require manual setup, leading to inefficiencies. For instance, an agent might take an unnecessarily long time to fill out a spreadsheet cell by cell instead of executing a single command. This limitation stems from the fact that both the interfaces and the knowledge of how to use them are designed by humans, which can’t keep up with the rapid evolution of applications and workflows. This is what's called a lack of adaptability in agent design. To address this, the authors propose a system called Agent S4, which autonomously creates and refines interfaces based on the experiences of task-specific agents. The core idea is that a meta-agent observes how these task agents perform on various synthetic tasks, learns from their successes and failures, and then evolves the interfaces they use. By employing a population-based evolution strategy, the system selects the most effective interface designs based on their performance on unseen validation tasks. This leads to significant improvements, as demonstrated by Agent S4 achieving a 21.3% binary score on OSWorld V2, outperforming existing models like GPT-5.5 and Claude Opus 4.8 while being more cost-effective. This suggests that evolving interfaces can be a powerful complement to advancements in AI models, making them more capable in real-world applications.

Novelty
8.0
Reliability
7.5
arxiv/2610.28601 →
PDF preview for Text-to-Image Generative Modeling Without Language Pretraining
PASS ✓

Text-to-Image Generative Modeling Without Language Pretraining

2026.10.19visioncode

Keshigeyan Chandrasegaran, Yue Zhao, Armin W. Thomas, et al.

Imagine you're building a system that generates images based on text descriptions. Traditionally, these systems rely heavily on large-scale language models trained on vast amounts of internet data, which can be resource-intensive and may not always yield the best results. This approach can lead to inefficiencies, especially when the language model doesn't directly contribute to the image generation process, which is what's called over-reliance on language pretraining. It can also create bottlenecks in training time and computational resources, making it harder for smaller teams to innovate in this space. To address these challenges, Halcyon introduces a family of multimodal models that are trained from scratch on a large dataset of image-text pairs, bypassing the need for extensive language pretraining. The intuition here is that by focusing directly on the relationship between images and their textual descriptions, these models can learn to generate images more efficiently. Halcyon demonstrates that it can outperform existing models while using significantly less computational power, showing that strong text-to-image systems can be built without the traditional reliance on language models. This shift means that builders can explore more efficient pathways to create T2I systems, potentially democratizing access to advanced image generation technologies.

Novelty
8.5
Reliability
8.0
arxiv/2610.26863 →
PDF preview for Can It Actually Work? Synthesizing Functional CAD Mechanisms
PASS ✓

Can It Actually Work? Synthesizing Functional CAD Mechanisms

2026.10.19agentscode

Wenqian Zhang, Yangyi Huang, Zigeng Xu, et al.

Imagine you're designing a complex mechanical system, like a robot arm or a new type of vehicle. You might have a general idea of what you want it to do, but translating that into a working design can be tricky. Current methods often rely on visual inspections or basic simulations, which can miss critical functional failures. This is what's called the problem of underspecified requests, where the design might look good but doesn't actually perform as intended. For instance, a mechanism might visually resemble a working model but fail to operate correctly under real conditions due to overlooked interactions between components. This leads to wasted time and resources in the design process. To address these challenges, the authors propose a framework called FunCAD-Harness. The idea is to take abstract functional requirements and convert them into specific physical tests that can be simulated. By using feedback from these simulations, the framework helps refine the designs iteratively, ensuring that they meet the intended functional criteria. They also introduce FunCADBench, a benchmark that evaluates designs across various mechanism families, focusing on their ability to perform interdependent and multi-step operations. Compared to traditional methods, FunCAD-Harness significantly enhances the ability to identify mechanical failures that aren't visible through mere visual inspection. This leads to higher success rates in functional designs, marking a notable advancement in how CAD agents can interpret and realize human intent in engineering tasks.

Novelty
8.0
Reliability
7.5
arxiv/2610.26861 →
PDF preview for Supervised Learning with Quantum Hamiltonian Embeddings
PASS ✓

Supervised Learning with Quantum Hamiltonian Embeddings

2026.10.19infra

Riccardo Molteni, Minjun Jeon, Paolo Braccia, et al.

Imagine you're working on a machine learning model that needs to classify complex data, but you're limited by the computational power of classical systems. Traditional methods often struggle with scalability and efficiency, especially when dealing with large datasets or intricate patterns. This is where quantum computing comes in, but until now, there hasn't been a solid framework that guarantees performance and trainability in quantum machine learning. The challenge has been to effectively harness quantum mechanics for practical applications without losing the ability to train and infer efficiently. This is what's called the 'trainability problem' in quantum machine learning. The authors propose a solution with quantum Hamiltonian embeddings, which encode classical data into a parameterized Hamiltonian. By optimizing this Hamiltonian, they can approximate its ground state, which then serves as the classification rule. This approach not only allows for efficient gradient estimation but also provides generalization guarantees under certain cryptographic assumptions. The framework has been tested on IBM's quantum processors using standard datasets, showcasing its potential for real-world applications. For builders, this means a new avenue for developing machine learning models that leverage quantum advantages, potentially outperforming classical methods in specific tasks.

Novelty
8.5
Reliability
7.5
arxiv/2610.26833 →
PDF preview for AI-Driven Reproducibility and Analytical Robustness in Scientific Discovery
PASS ✓

AI-Driven Reproducibility and Analytical Robustness in Scientific Discovery

2026.10.16agents

Shicheng Liu, Krista Opsahl-Ong, Andrew Drozdov, et al.

Imagine you're a researcher trying to validate findings from numerous medical studies, but the process is tedious and often prone to human error. Currently, researchers rely heavily on manual efforts to reproduce results, which can lead to inconsistencies and missed insights. This is what's called the reproducibility crisis, where many published studies cannot be reliably replicated due to various analytical choices and data handling methods. The challenge lies in efficiently assessing the robustness of these findings without overwhelming experts with every detail. To address this, the authors developed SEER-Repro, a benchmark that includes 20 published studies from the SEER cancer registry, along with the necessary data for reproduction. They created an AI agent capable of reproducing a significant portion of claims made in these studies and established a pipeline that not only reproduces findings but also tests their robustness by analyzing the underlying analytical choices. This approach flags potentially impactful decisions for expert review, streamlining the validation process and enhancing the reliability of scientific findings. Compared to traditional methods, this work represents a shift towards leveraging AI to support scientific rigor, making it easier for researchers to focus on critical insights rather than getting bogged down in the minutiae of reproduction.

Novelty
8.0
Reliability
7.5
arxiv/2610.23845 →
PDF preview for Task-aligned spectral inductive biases in parameterized quantum circuits
PASS ✓

Task-aligned spectral inductive biases in parameterized quantum circuits

2026.10.16data

Felix Frohnert, Adrián Pérez-Salinas, Sebastian Lange, et al.

Imagine you're developing a quantum machine learning model to classify complex signals, like those from radar systems. The challenge lies in how to structure the model so it effectively learns from the data, especially when the data is limited. Traditional methods often struggle because they don't tailor the model's architecture to the specific characteristics of the task, leading to poor performance when the model encounters new or varied inputs. This mismatch can result in what's called overfitting, where the model learns too much from the training data but fails to generalize to new examples. To address this, the authors propose a method that uses data reuploading quantum circuits, which incorporate a fixed, task-specific query alongside the input data. This allows the model to focus on relevant features of the signal without adding unnecessary complexity. By aligning the circuit's architecture with the task's requirements, they show that it can significantly improve learning outcomes, particularly in scenarios with limited data. Compared to previous approaches that didn't consider such alignment, this method offers a clearer pathway for designing quantum circuits that are better suited for specific applications, like classifying radar signals before image formation.

Novelty
8.5
Reliability
7.5
arxiv/2610.23834 →
PDF preview for Self-Building Labs
PASS ✓

Self-Building Labs

2026.10.16agentscode

Jiaru Bai, Yuchi Zhao, Han Hao, et al.

Imagine you're a scientist trying to conduct experiments in a lab, but every time you want to explore a new idea, you face the tedious task of configuring equipment and programming robots to perform the necessary tasks. This manual setup process is often a bottleneck, slowing down scientific discovery and limiting the flexibility of existing automated systems. When researchers want to adapt their experiments, they find themselves stuck in a cycle of engineering work, which is what's called a lack of adaptability in self-driving laboratories (SDLs). These systems can run predefined experiments but struggle to accommodate new scientific goals without significant human intervention. To address this challenge, the concept of a self-building laboratory (SBL) emerges. Instead of relying on fixed procedures, SBLs can autonomously design and configure their laboratory setups based on high-level objectives provided by researchers. This means that whether starting from scratch or building on existing setups, the SBL can create the necessary lab layout, digital twin, and workflows, effectively reducing the burden on human researchers. By validating this approach through a real-world quantum-dot synthesis experiment, the SBL demonstrates its ability to scale and adapt across different robotic systems and laboratory configurations. This shift allows researchers to focus more on scientific inquiry rather than the intricacies of lab automation, making the process more accessible and efficient.

Novelty
8.5
Reliability
7.5
arxiv/2610.23826 →
PDF preview for Learning without relearning physical symmetry: an SO(3)-equivariant convolutional network (CNN) on the sphere
PASS ✓

Learning without relearning physical symmetry: an SO(3)-equivariant convolutional network (CNN) on the sphere

2026.10.16data

Joshua Williamson, Niall Jeffrey, Lorne Whiteway

Imagine you're working on simulations in cosmology, where data is often represented on a sphere. Traditional methods can struggle with this, leading to inefficiencies and inaccuracies because they don't account for the sphere's inherent symmetry. This can result in simulations that require excessive computational resources, which is particularly problematic when high-fidelity simulations are needed for accurate scientific analysis. This issue is known as the inefficiency of non-equivariant methods, which can bias results and force reliance on less accurate models. To tackle this, the authors propose a spherical convolutional neural network (CNN) that respects the symmetry of spherical data. By using a gauge equivariant mesh architecture, they ensure that the network inherently understands the spherical structure without needing to learn it from the data. This architecture employs steerable filters and spin-weighted features to achieve exact equivariance, which significantly reduces simulation errors. The result is a method that not only enhances the accuracy of dense gradient regression but also excels in tasks like cosmic microwave background foreground removal and denoising. Compared to previous approaches, this new architecture allows for more efficient simulations, particularly in simulation-based inference where computational resources are limited. It enables tighter posteriors in cosmological lensing tasks, making it a valuable tool for researchers needing reliable analyses of spherical data.

Novelty
8.5
Reliability
8.0
arxiv/2610.23821 →
PDF preview for Discovering state-of-the-art quantum circuits with large language models
PASS ✓

Discovering state-of-the-art quantum circuits with large language models

2026.10.15infracommunity code

Andi Gu, Alek H. Kemeny, Susanne F. Yelin, et al.

Imagine you're working on building a quantum computer that can solve complex problems faster than classical computers. The challenge lies in creating efficient quantum algorithms, especially since quantum operations must be reversible, which isn't a requirement in classical computing. This reversibility constraint can lead to inefficiencies in circuit design, making it hard to optimize the resources needed for computation. Current methods often struggle to balance the number of operations and the qubits used, leading to suboptimal solutions. This is what's called the Toffoli-qubit trade-off, where you want to minimize both the number of Toffoli gates and qubits used in a circuit. To address these challenges, the authors propose a framework where large language models (LLMs) generate circuit designs, and an independent evaluator assesses their effectiveness. By applying this method to various tasks, they found that the circuits designed by LLMs significantly reduced the resource costs in seven out of eight tasks. Notably, they discovered a new architecture for prime-field modular inversion that allows for a classical algorithm to be used effectively in a reversible context. This advancement not only improves the efficiency of quantum circuits but also opens up new avenues for algorithmic design in quantum computing, making it easier for builders to create more powerful quantum systems.

Novelty
8.5
Reliability
7.5
arxiv/2610.22367 →
PDF preview for KnowGPO: Knowledge-Grouped Policy Optimization for Search Agents
PASS ✓

KnowGPO: Knowledge-Grouped Policy Optimization for Search Agents

2026.10.15agentscode

Siqi Chen, Zhengxi Lu, Yuchen Yan, et al.

Imagine you're building an AI that needs to navigate complex tasks, like answering questions based on a vast amount of information. The challenge lies in figuring out which decisions led to success, especially when the AI interacts over many steps and the context can be messy. Traditional reinforcement learning methods often provide a single reward at the end of a task, which can obscure the contributions of individual actions — this is what's called outcome-based reinforcement learning. When trying to improve credit assignment, existing methods often rely on surface-level observations or internal model signals, which can be unreliable in deep search scenarios where the context is long and noisy. To address this, the authors propose a framework called KnowGPO, which focuses on the knowledge gained throughout the task rather than just the observable states. By breaking down the information needed to answer a query into smaller knowledge conditions, KnowGPO tracks the progress of a trajectory based on the knowledge it accumulates at each step. This allows for a more nuanced comparison of trajectories that share similar knowledge states, and the incremental knowledge gained serves as a reward signal. Compared to previous methods, KnowGPO consistently outperforms them by a notable margin, suggesting that this approach could lead to more effective AI systems capable of handling complex, knowledge-intensive tasks.

Novelty
8.0
Reliability
7.5
arxiv/2610.22331 →
PDF preview for A team of Gemini 4 Argon agents beats Minecraft
PASS ✓

A team of Gemini 4 Argon agents beats Minecraft

2026.10.15agents

Maxence Faldor, Satinder Singh, Roberta Raileanu

Imagine you're trying to build an AI that can work together with others to achieve a complex goal, like defeating a formidable opponent in a game. In traditional setups, AI agents often rely on pre-defined roles or human-written logic, which can lead to rigid strategies and limited adaptability. This approach can break down when faced with unexpected challenges or when coordination among agents falters, leading to failures in execution and planning — a situation known as coordination breakdown. In this study, the researchers placed four AI agents in a Minecraft world and tasked them with defeating the Ender Dragon, allowing the agents to autonomously plan, code, and debug their strategies without any human intervention or pre-scouted resources. They utilized an open-source library called Mineflayer to control their actions and communicate, resulting in a remarkable achievement: the agents wrote nearly 2,800 programs and successfully defeated the dragon after over 27 hours of gameplay, despite numerous setbacks along the way. This showcases a significant leap in the ability of AI to handle complex, long-term tasks that require continuous adaptation and teamwork, moving beyond previous work that often relied on more constrained environments or human oversight.

Novelty
8.5
Reliability
7.5
arxiv/2610.22319 →
PDF preview for Learning to Steer LLM Agents and Multi-Agent Systems
PASS ✓

Learning to Steer LLM Agents and Multi-Agent Systems

2026.10.15agents

Leyang Shen, Yaxin Gong, Yang Zhang, et al.

Imagine you're building a complex AI system that needs to work with other agents to complete tasks over time, like coordinating a team to gather information or perform actions. The challenge is that as these agents execute their tasks, they can lose sight of the overall goal, leading to wasted resources and incorrect outcomes. This issue, known as goal drift, often occurs in real-world applications where the environment is dynamic and unpredictable. Current systems typically lack a mechanism to correct course during execution, which can result in significant inefficiencies and failures. To address this, the authors propose a steering agent that monitors the execution of tasks in real-time and intervenes when it detects goal drift. This agent uses a dual-path approach: a low-cost fast path for quick interventions and a high-cost slow path for more complex corrections. By training these paths together using reinforcement learning, the steering agent learns to assess when and how to intervene effectively. The results show that this approach not only enhances the performance of both single-agent and multi-agent systems but also allows for generalization to new tasks and executors without needing retraining. For builders, this means a more reliable way to ensure that AI systems stay aligned with their intended goals, even in complex and changing environments.

Novelty
8.0
Reliability
7.5
arxiv/2610.22316 →
PDF preview for PhySGA: A Physics-Space Grounded Agentic Framework for Generalizable and Interactive 3D Composition
PASS ✓

PhySGA: A Physics-Space Grounded Agentic Framework for Generalizable and Interactive 3D Composition

2026.10.14agentscode

Weichen Lyu, Chong Xia, Mingyu Dong, et al.

Imagine you're designing a virtual environment where robots need to assemble complex structures, like a hanging sculpture or a multi-part machine. Current methods often fall short because they either rely on static predictions of object positions or generate images that don't account for the physical interactions between objects. This leads to issues like objects not staying in place due to gravity or failing to fit together correctly, which is known as the problem of physical plausibility in simulations. These failures highlight the limitations of existing approaches that lack a grounded understanding of physics and interactive construction processes. To tackle these challenges, a new framework called PhySGA has been developed. It combines agent exploration with physical simulation, allowing for a more dynamic and realistic assembly of various object types. The framework features an Assembly Agent that plans the overall structure and makes coarse adjustments, while a Critic Agent focuses on the finer details of how objects interact physically. Additionally, Action Routers translate high-level plans into specific actions within the simulation, and a Self-Evolving Skill Library helps the system learn from past experiences to improve future attempts. Compared to previous methods, PhySGA shows significant improvements in how well it maintains the relationship between objects, adheres to physical laws, and produces visually appealing results, making it a valuable tool for anyone working on 3D content creation or robotic simulations.

Novelty
8.5
Reliability
7.5
arxiv/2610.20560 →
PDF preview for PrismaCoder: Pushing the Boundaries of Open Multimodal Code Intelligence through Decomposed Rubric Synthesis
PASS ✓

PrismaCoder: Pushing the Boundaries of Open Multimodal Code Intelligence through Decomposed Rubric Synthesis

2026.10.14multimodalcode

Qiushi Sun, Jingyang Gong, Yang Liu, et al.

Imagine you're developing an AI that can write code and generate visual outputs like charts or webpages based on simple text prompts. The challenge lies in ensuring that the generated code not only runs correctly but also produces visually appealing results. Current methods often fall short because they either focus on code correctness, which doesn't guarantee visual fidelity, or rely on task-specific checks that don't generalize well. This disconnect leads to failures in producing high-quality outputs, which is a significant barrier for open-source advancements in this area. To address these issues, the authors propose a new approach that starts with data quality. They introduce PrismaForge, a hierarchical data pipeline that uses a synthesized rubric to evaluate and curate data based on three critical factors: correctness, construction quality, and visual appeal. This rubric not only filters the training data but also guides reinforcement learning for visual coding tasks. By leveraging this pipeline, they create PrismaCoder-2M, the largest and most diverse open dataset for multimodal code intelligence, and train two models, PrismaCoder-9B and PrismaCoder-35B, which outperform existing open models and compete with proprietary systems. This work represents a meaningful step forward in the field, providing a robust framework for improving multimodal coding performance across various model architectures.

Novelty
8.5
Reliability
8.0
arxiv/2610.20538 →
PDF preview for Hybrid Reasoning Agents
PASS ✓

Hybrid Reasoning Agents

2026.10.13agentscode

Jiaru Zou, Yunzhe Qi, Sirui Chen, et al.

Imagine you're developing an AI that needs to think and act in a way that goes beyond just responding to text. Current large language models (LLMs) often struggle with this because they rely heavily on text for reasoning and interaction, which can lead to issues like losing context over time or making poor tool choices. This is what's called context drop or tool misalignment, where the agent fails to adapt to ongoing tasks or changes in the environment. These limitations can hinder the effectiveness of AI in real-world applications where continuous interaction is necessary. To address these challenges, the authors propose Hybrid Reasoning Agents, or HybridAgents, which can fluidly switch between latent reasoning and text-based actions. The key innovation here is a lightweight component called HybridLink that allows the agent to maintain a continuous working memory, preserving context across interactions. This means that the agent can think in a more abstract way while still being able to communicate effectively through text. They also introduce two post-training algorithms, HybridSFT and HybridRL, which help the agent learn when to use latent reasoning versus when to act through text. Compared to existing LLM agents, HybridAgent shows a significant performance boost of over 10% across various benchmarks, while also being more efficient in terms of token usage and inference speed. This could be a game-changer for developers looking to build more capable and responsive AI systems.

Novelty
8.0
Reliability
7.5
arxiv/2610.18861 →
PDF preview for The Last Remote Sensing Model Built by Humans? Casting Any Earth Observation Task as Recursive Self-Improvement
PASS ✓

The Last Remote Sensing Model Built by Humans? Casting Any Earth Observation Task as Recursive Self-Improvement

2026.10.13agentscommunity code

Sijie Zhao, Zeqi Zhou, Heli Qi, et al.

Imagine you're tasked with monitoring environmental changes using satellite imagery. Traditionally, experts painstakingly design and tune models for each specific task, which can be time-consuming and often leads to suboptimal results. This process can break down when faced with new challenges, as it relies heavily on human expertise and can struggle with limited data or varying conditions — a situation known as the 'data scarcity problem.' As a result, many Earth observation tasks remain underexplored or poorly executed due to the manual nature of model development. The authors propose a solution where a coding agent takes over the model-building process. By defining a 'harness' that outlines the tools available and a 'verifier' that sets success criteria, any Earth observation task can be automated. This means that the agent can learn and adapt by itself, improving its models based on its own outputs. The approach allows for a more flexible and efficient way to tackle various tasks, from those with limited labeled data to cross-domain adaptations. In tests across four different Earth observation benchmarks, models built by the agent not only surpassed existing state-of-the-art results but also maintained high accuracy with just a fraction of the training labels. This shift means that instead of experts crafting every detail, they can focus on designing the frameworks that guide the agents, leading to continuous improvement in model performance as the agents learn and evolve.

Novelty
8.5
Reliability
7.5
arxiv/2610.18845 →
PDF preview for AI Models Can Provably Hide Arbitrary Capabilities
PASS ✓

AI Models Can Provably Hide Arbitrary Capabilities

2026.10.09infra

Andis Draguns, Sumeet Ramesh Motwani, Raymond Douglas, et al.

Imagine you're developing an AI model that needs to be safe and reliable before it's deployed in critical applications, like predicting chemical reactions. Today, we often rely on capability evaluations to uncover hidden behaviors that could lead to dangerous outcomes. However, these evaluations assume that we can easily elicit and interpret all model capabilities, which isn't always true. For instance, adversarial conditions can hide certain functionalities, making them hard to detect, a situation known as backdoor attacks. This is where the current methods break down, as they fail to account for the possibility of hidden circuits that can execute arbitrary computations only when triggered by a secret signal. To address this, the authors propose a method that embeds encrypted neural networks within the model weights, using digital lockers to keep these hidden circuits secure. They demonstrate that even with full access to the model weights, eliciting these hidden capabilities remains challenging under cryptographic assumptions. By implementing their approach in PyTorch and testing it against various elicitation techniques, they show that their method can resist attempts to uncover these hidden functionalities. This work highlights a significant limitation in the current approach to capability audits, suggesting that simply relying on elicitation methods may not be sufficient for ensuring model safety in real-world applications.

Novelty
8.5
Reliability
7.0
arxiv/2610.13928 →
PDF preview for Designing Protein Structures from Natural Language
PASS ✓

Designing Protein Structures from Natural Language

2026.10.09data

Joseph Lee, Yanjing Li, Bo Qiang, et al.

Imagine you're a scientist trying to design new proteins for specific functions, like creating a binder that can target a disease. Traditionally, this process involves complex models that require specific input formats for each property you want to design, which can be limiting and cumbersome. For instance, if you want a protein that binds to a particular target, you might need to manually adjust your input for every different property, leading to inefficiencies and potential failures in achieving the desired outcome — this is what's called a lack of flexibility in design objectives. To address this, the authors developed Prompteina, a model that allows you to specify design objectives using natural language, similar to how you might describe an image you want to generate. By training on a massive dataset of protein structures paired with descriptive captions, Prompteina can generate all-atom protein structures that align closely with the intended functions described in plain language. This approach not only simplifies the design process but also significantly improves the accuracy of the generated proteins, outperforming existing models on a wide range of structural properties and specific design targets. For someone building in this space, Prompteina represents a shift towards more intuitive and flexible protein design methodologies, making it easier to explore a broader range of functional possibilities.

Novelty
8.5
Reliability
8.0
arxiv/2610.13917 →
PDF preview for A Balanced Data Diet: Addressing the Exploration Bottleneck in Mega-Scale RL for Robot Control
PASS ✓

A Balanced Data Diet: Addressing the Exploration Bottleneck in Mega-Scale RL for Robot Control

2026.10.08scalingcode

Octi Zhang, Mateo Guaman Castro, Patrick Yin, et al.

Imagine you're developing a robot that needs to navigate various terrains and manipulate objects with precision. Current methods in reinforcement learning (RL) often rely heavily on predefined rules and demonstrations, which can be labor-intensive and limit the robot's adaptability. This is particularly problematic when scaling to more complex tasks, as the learning process can waste valuable experience on scenarios the robot has already mastered or cannot yet handle, leading to inefficiencies in training. This issue is known as experience waste, where the learning signal is diluted by irrelevant task configurations. To address this, the authors propose a method called Success Guided Sampling (SGS), which intelligently focuses the training process on task configurations that are just beyond the robot's current capabilities. By concentrating on these challenging scenarios, SGS allows for more effective use of parallel simulations, enabling the robot to learn more efficiently across a vast number of environments. This approach not only improves the robot's performance in complex tasks like quadruped locomotion and assembly but also facilitates the transfer of learned skills to real-world applications, showcasing a practical advancement over previous methods that struggled with similar challenges.

Novelty
8.0
Reliability
7.5
arxiv/2610.12465 →
PDF preview for CSF: Contextual Safety Filtering for Motion Generators
PASS ✓

CSF: Contextual Safety Filtering for Motion Generators

2026.10.08agents

Lizhi Yang, Yiling Hou, Yao Tang, et al.

Imagine you're developing a robot that needs to navigate through crowded spaces, interacting with people and objects safely. Current systems often rely on predefined safety rules or geometric constraints, which can fail in dynamic environments. For instance, a robot might misinterpret a prompt and perform an action that endangers a person nearby, leading to unsafe situations. This is what's called a lack of scene awareness, where the robot doesn't understand the context of its actions. To address this, the paper introduces contextual safety filtering (CSF), a method that grounds safety rules in real-world scenarios without needing extensive retraining. By using reference trajectories that define safe and unsafe actions, CSF can dynamically adjust the robot's behavior based on the context it encounters. This approach has been tested across various pretrained motion generators and has shown to reduce dangerous events by up to 90%, while still allowing for 88-100% of safe motions to occur. Compared to previous methods, CSF provides a more nuanced understanding of safety in motion generation, making it a valuable tool for builders looking to deploy robots in complex environments where human interaction is a factor.

Novelty
8.0
Reliability
7.5
arxiv/2610.12467 →
PDF preview for Bi-FORK: Generative Modeling of High-Dimensional Bifurcating Systems
PASS ✓

Bi-FORK: Generative Modeling of High-Dimensional Bifurcating Systems

2026.10.08scaling

Anna Zimmel, Fleur Hendriks, Markus Holzleitner, et al.

Imagine you're designing a system to predict how structures behave under stress, like a bridge or a building. In many cases, a single input can lead to multiple valid outcomes, such as different ways a beam might buckle under load. Traditional models often assume a one-to-one relationship between inputs and outputs, which can lead to oversimplified predictions and missed critical behaviors. This limitation is particularly evident in complex physical systems where bifurcations occur, leading to multiple potential states from the same initial conditions. This is what's called a symmetry-breaking bifurcation, and it poses a challenge for existing deep learning methods that typically struggle to capture such complexities. To tackle this, a new framework called Bi-FORK has been developed. It learns to generate these one-to-many solution maps by effectively modeling the underlying dynamics of the system. By using techniques like latent flow matching and repulsion-guided sampling, Bi-FORK can explore and recover distinct solution branches in a single pass, maintaining coherence in both space and time. Compared to previous methods, Bi-FORK scales significantly better, handling high-dimensional systems with thousands of data points while accurately capturing the multimodal nature of solutions. For builders, this means you can now model complex physical phenomena more accurately, leading to better designs and predictions in engineering and materials science.

Novelty
8.5
Reliability
7.5
arxiv/2610.12449 →
PDF preview for VioLA: Learning Generalist Humanoid Control Policies from Human Data
PASS ✓

VioLA: Learning Generalist Humanoid Control Policies from Human Data

2026.10.08agents

Mert Albaba, Jens Beißwenger, Anna Manasyan, et al.

Imagine you're building a humanoid robot that needs to follow complex instructions, like walking or manipulating objects. The challenge lies in the robot's intricate action space, where movements of arms, legs, and fingers must be coordinated while maintaining balance. Current methods often require fine-tuning on specific tasks using limited teleoperated demonstrations, which can be inefficient and time-consuming. This is what's called the problem of high-dimensional control and scarcity of demonstrations. The authors propose a solution by changing the way the robot interprets instructions. Instead of directly predicting joint movements, their method, VioLA, predicts motion latents that represent body and hand movements in a more abstract way. By mapping human motion to these latents, they can leverage a vast dataset of human demonstrations, allowing the robot to learn from 140.6 million frames, with 93.2% being human-generated. This enables the robot to perform locomotion and manipulation tasks without needing task-specific fine-tuning, achieving impressive success rates compared to existing models. For builders, this means a more efficient way to train humanoid robots, reducing the need for extensive manual demonstrations and allowing for more versatile applications in real-world scenarios.

Novelty
8.5
Reliability
8.0
arxiv/2610.12435 →
PDF preview for Private online learning and prediction for Littlestone classes
PASS ✓

Private online learning and prediction for Littlestone classes

2026.10.05data

Amartya Sanyal

Imagine you're developing a machine learning system that needs to learn from data while ensuring user privacy. In online learning, the system must provide a hypothesis at each step, while in online prediction, it only needs to make predictions without revealing its internal workings. Current methods often struggle with balancing privacy and performance, leading to mistakes that can accumulate over time, especially when dealing with adversarial conditions. This is what's called the mistake bound problem, where the system's performance can degrade significantly under certain conditions. The authors tackle this by establishing new theoretical bounds for both online learning and prediction, focusing on how the complexity of these tasks scales with time and the underlying data structure. They show that for private online learning, the expected mistakes grow with the logarithm of time, while private prediction can achieve a much lower mistake rate, independent of time. This distinction is crucial for developers, as it highlights the trade-offs between privacy and performance in real-world applications, providing clearer guidelines for building robust systems.

Novelty
8.0
Reliability
7.5
arxiv/2610.06822 →
PDF preview for RNADyn: A Benchmark for Generating and Understanding RNA Dynamics
PASS ✓

RNADyn: A Benchmark for Generating and Understanding RNA Dynamics

2026.10.02datacode

Yiming Huang, Lennart Bastian, Hanqun Cao, et al.

Imagine you're trying to understand how RNA molecules behave in different environments, which is crucial for drug design and genetic research. Currently, researchers often rely on static models that don't capture the dynamic nature of RNA, leading to gaps in understanding how these molecules actually function. Existing methods typically separate the tasks of generating molecular trajectories and analyzing their dynamics, which can result in incomplete insights and missed correlations between structure and function. This is what's called a disconnect in the modeling approach. To address this, the authors developed RNADynBench, a comprehensive benchmark that includes thousands of quality-controlled RNA molecular dynamics trajectories. They also introduced RNADynNet, a unified model that simultaneously generates trajectories and extracts meaningful dynamics information from a single RNA conformer. By integrating techniques like coordinate denoising and physical grounding, RNADynNet connects trajectory generation with dynamics representation learning, improving the accuracy of both generated data and the insights derived from it. Compared to previous work, this approach not only provides a standardized dataset for RNA dynamics but also enhances the understanding of RNA behavior through a cohesive modeling framework. For builders in the field, this means having access to better tools for simulating and interpreting RNA dynamics, ultimately leading to more informed decisions in research and application.

Novelty
8.0
Reliability
7.5
arxiv/2610.03712 →
PDF preview for Language Models that Play Chess and Explain Their Moves
PASS ✓

Language Models that Play Chess and Explain Their Moves

2026.10.02agentscommunity code

Adithya Bhaskar, Jeffrey Cheng, Danqi Chen

Imagine you're developing a chess AI that not only plays at a high level but also explains its moves in a way that makes sense to human players. Current chess engines can dominate the game but often leave users in the dark about their decision-making processes. On the flip side, language models can generate explanations, but their lack of chess expertise limits their usefulness. This creates a gap where players want to understand the reasoning behind moves but struggle to find a tool that can both play well and articulate its thought process clearly. This is what's called the interpretability problem in AI. To address this, the authors propose a new model called Queen, which combines a chess-specific encoder with a language model through a unique architecture. The model learns to explain its moves by analyzing positions after making its top candidate moves, refining its explanations iteratively. This approach not only allows Queen to play at a Grandmaster level but also to provide fluent and coherent explanations that rival those of advanced language models. Compared to existing chess engines, Queen's ability to articulate its reasoning while maintaining high playing strength represents a meaningful step forward for AI in games, suggesting a broader application for similar frameworks in other domains like robotics and complex decision-making tasks.

Novelty
8.5
Reliability
7.5
arxiv/2610.03695 →
PDF preview for Hierarchical Continuous Diffusion Language Models
PASS ✓

Hierarchical Continuous Diffusion Language Models

2026.10.01reasoningcode

Hui Ren, Zihan Li, Chang Liu, et al.

Imagine you're building a language model that needs to generate coherent text while also reasoning through complex structures, like solving a Sudoku puzzle. Current models often generate tokens one at a time, which can lead to inconsistencies because each token is chosen independently, breaking the connections that should exist between them. This issue, known as the independence of token sampling, can result in outputs that lack coherence or fail to satisfy global constraints. Continuous models try to address this by maintaining a shared state, but they struggle to connect that state back to valid token outputs until the very end of the process, which can limit their effectiveness in generating meaningful sequences. To tackle these challenges, the authors propose a new method that combines the strengths of both discrete and continuous models. By using a hierarchical approach, they create a continuous latent space that evolves as tokens are generated, allowing for a more integrated and coherent generation process. This method not only improves the accuracy of structured reasoning tasks like Sudoku and Countdown but also enhances the quality of language modeling on datasets like LM1B. For builders, this means a more robust framework for developing applications that require both reasoning and natural language generation, potentially leading to more reliable and contextually aware AI systems.

Novelty
8.5
Reliability
7.5
arxiv/2610.02193 →
PDF preview for Generative modeling of intrinsically disordered protein regions by reinforcing sparse autoencoder features
PASS ✓

Generative modeling of intrinsically disordered protein regions by reinforcing sparse autoencoder features

2026.10.01datacode

Jason X. Liu, Sebastian Ibarraran, Frank Hu, et al.

Imagine you're trying to design proteins that can perform specific functions in a cell, like regulating genes or transmitting signals. The challenge is that many proteins have regions that don't fold into stable structures, known as intrinsically disordered regions (IDRs). Traditional methods for protein design rely on understanding these stable structures, which means they often overlook the unique properties of IDRs. This leads to a gap where existing models fail to generate effective sequences for these flexible regions, which is what's called a bias towards folded domains. To address this, researchers developed IDiom, a specialized protein language model trained on a massive dataset of predicted IDRs. This model generates diverse protein sequences that not only mimic the natural characteristics of IDRs but also allow for control over specific functional features through a method called reinforcement learning with sparse autoencoder features (RL-SAE). By rewarding the generation of sequences that activate desired features, IDiom can produce IDRs that are more likely to perform well in biological contexts. Compared to previous methods, IDiom and RL-SAE significantly improve the ability to design IDRs with targeted functionalities, making it easier to create proteins that can be tailored for specific roles in cellular processes.

Novelty
8.5
Reliability
7.5
arxiv/2610.02189 →
PDF preview for Cogentic: Multi-Agent Orchestration for Automated Proof Discovery
PASS ✓

Cogentic: Multi-Agent Orchestration for Automated Proof Discovery

2026.09.30agentscode

Yang Cai, Vineet Gupta, Yanchen Jiang, et al.

Imagine you're a mathematician trying to solve a complex open problem, like finding new insights in auction theory or mechanism design. Traditional methods often rely on individual researchers generating ideas, which can lead to missed opportunities and incomplete explorations. This is particularly challenging when problems require considering multiple competing conjectures and retaining progress over time, which is where many approaches fall short. This is what's called the single-shot generation failure, where one-off attempts don't capture the iterative nature of deep mathematical inquiry. To address these challenges, Cogentic employs a multi-agent system that orchestrates a group of independent provers, each exploring different proof directions. This iterative prove-verify loop allows for a more thorough exploration of ideas, as the orchestrator allocates tasks and verifies outputs through adversarial checks. The confirmed results are then stored in a verified ledger, enabling future rounds to build on previous findings. By using the Gemini model as a foundation, Cogentic has successfully produced novel results on five open problems, all of which were independently verified by experts. This approach not only enhances the efficiency of proof discovery but also sets a new standard for how mathematical research can be conducted using AI.

Novelty
8.5
Reliability
7.5
arxiv/2609.40324 →
PDF preview for Skill-Space Shooting for Autonomous Robot Policy Improvement
PASS ✓

Skill-Space Shooting for Autonomous Robot Policy Improvement

2026.09.29agentscode

Zihang Rui, Renhao Wang, Haoxu Huang, et al.

Imagine you're building a robot that needs to adapt to new tasks in the real world, like navigating a busy street or picking up objects. The challenge is that these robots often struggle when they encounter situations they weren't specifically trained for, leading to failures that can be hard to correct without human intervention. This reliance on human guidance can slow down the learning process and limit the robot's ability to improve autonomously. This is what's called the problem of adaptability in robotic systems, where they fail to generalize their learned behaviors to new contexts effectively. To address this, the authors propose a method called skill-space shooting, which allows robots to explore and utilize short, reusable skills that can be applied across various tasks. Instead of needing a human to demonstrate every correction, the robot can use its foundation model to reason about these skills and apply them to improve its task performance. By turning successful trials into learnable corrections, the robot can autonomously refine its policy over time. This approach not only enhances the robot's ability to learn from its experiences but also allows for sharing skills across different tasks, reducing the amount of teaching required for new challenges. Compared to previous methods, this offers a more scalable and generalizable way to improve robotic policies in real-world applications.

Novelty
8.0
Reliability
7.5
arxiv/2609.38178 →
PDF preview for Imagine3D-LLM: Teaching MLLMs to Imagine 3D Scenes Before Answering
PASS ✓

Imagine3D-LLM: Teaching MLLMs to Imagine 3D Scenes Before Answering

2026.09.29reasoningcode

Jaewoo Jung, Hyeonseo Yu, Honggyu An, et al.

Imagine you're building an AI that needs to understand a room from different angles, like a virtual assistant that can help you rearrange furniture. Current models excel at analyzing single images but struggle to piece together a coherent 3D view from multiple perspectives. This limitation often leads to errors in understanding spatial relationships, which is crucial for tasks like navigation or object manipulation — a failure mode known as poor spatial reasoning. To address this, the authors propose Imagine3D-LLM, which mimics how humans perceive 3D spaces by focusing on identifying common objects across views and inferring their relative positions. Instead of relying solely on detailed geometric data, this model uses a compact representation of the scene, created from summary tokens that are trained to reconstruct the 3D layout. This method not only improves the model's ability to understand spatial relationships but also enhances the underlying image features, leading to better overall performance. Compared to previous approaches that heavily relied on pixel-level details, Imagine3D-LLM shows that a more abstract understanding of 3D space can yield superior results in spatial reasoning tasks. For builders, this means that integrating a more human-like approach to 3D understanding could significantly improve the capabilities of AI systems in real-world applications.

Novelty
8.0
Reliability
7.5
arxiv/2609.38177 →
PDF preview for Breakdown of Local Denoising as Semantic Speciation
PASS ✓

Breakdown of Local Denoising as Semantic Speciation

2026.09.29scaling

Guangkuo Liu, Mert Okyay, Yifan F. Zhang, et al.

Imagine you're developing a generative model that needs to create coherent and contextually relevant outputs, like generating text or images. A common challenge is understanding how the model decides on a specific category or theme for its output while also considering broader context. Often, models struggle with maintaining coherence over longer sequences, leading to issues like losing track of the main topic or generating irrelevant details — this is what's called nonlocality. Meanwhile, the model's ability to commit to a specific semantic class, known as speciation, can also falter, especially when the context becomes too complex or distant. These two issues can occur simultaneously, complicating the design of effective generative systems.  To address this, the authors explore the relationship between these two windows of behavior in generative models. They propose that the nonlocality window is inherently linked to the speciation window, suggesting that understanding semantic labels can help explain the correlations between distant tokens in the generated output. By establishing conditions under which both windows converge as the model scales, they identify a phase transition that could inform future model designs. This insight provides a clearer framework for understanding how to maintain semantic coherence in generative tasks, which is crucial for anyone building advanced AI systems.

Novelty
8.0
Reliability
7.5
arxiv/2609.38176 →
PDF preview for STEPQuant: When and Where Errors Matter in Delta-Rule Recurrent State Quantization
PASS ✓

STEPQuant: When and Where Errors Matter in Delta-Rule Recurrent State Quantization

2026.09.29infracode

Bingchen Yao, Haobo Xu, Haokun Lin, et al.

Imagine you're building a large language model that needs to serve many users simultaneously. As these models grow, they require significant memory to maintain their performance, especially when using linear attention mechanisms that rely on recurrent states. However, these states can become a memory bottleneck, particularly when serving multiple requests at once. A common approach to mitigate this is to quantize these states to lower precision, but this often leads to accuracy issues due to the propagation of quantization errors over time and across different parts of the model. This is what's called quantization error propagation, which can severely degrade performance in practical applications. To tackle this, the authors propose STEPQuant, a framework that intelligently allocates quantization precision based on how long the memory is expected to last and the impact of different parts of the model on the final output. By analyzing the distribution of state magnitudes and their effects on errors, STEPQuant can maintain high accuracy even with reduced precision. In experiments with large models like Qwen3.8-27B and Kimi-Linear-48B-A3B-Instruct, STEPQuant achieves impressive results, closely matching full precision accuracy while significantly reducing memory usage. This means that for builders, integrating STEPQuant could lead to more efficient models that are easier to deploy in real-world applications without sacrificing performance.

Novelty
8.0
Reliability
7.5
arxiv/2609.38169 →
PDF preview for Cropland PAtteRNS: Parallel Dimensional Attention Networks and Attention to Dataset Disparity for Crop Segmentation in Satellite Imagery Time Series Data
PASS ✓

Cropland PAtteRNS: Parallel Dimensional Attention Networks and Attention to Dataset Disparity for Crop Segmentation in Satellite Imagery Time Series Data

2026.09.29vision

Joseph Metcalfe, Sara Sharifzadeh, Fabio Caraffini

Imagine you're working on a project that involves analyzing satellite images to identify and segment different types of crops. The challenge lies in accurately distinguishing between crop types, especially when the data comes from various sources and formats. Current methods often struggle with this task, particularly when they rely on large datasets that may not be well-structured or when they use generic models that don't account for the unique characteristics of satellite imagery. This can lead to poor segmentation results, especially in complex scenarios where precise boundaries are crucial for agricultural analysis. This is what's called the problem of inadequate model specificity and dataset quality. To address these issues, the authors propose a new model that leverages a hybrid approach combining transformers and convolutional networks. Their model, called Cropland Parallel Attention and Refinement Network for Segmentation (PAtteRNS), uses self-attention mechanisms tailored for the temporal, spectral, and spatial dimensions of satellite data. This allows the model to focus on the most relevant features while significantly reducing computational complexity. By validating their approach through rigorous testing against existing models, they demonstrate that their method not only outperforms others in crop class segmentation but also highlights the importance of dataset quality and structure. This means that for builders in the field, adopting such specialized models could lead to more accurate and reliable crop segmentation, ultimately enhancing agricultural decision-making.

Novelty
8.0
Reliability
7.5
arxiv/2609.38165 →
PDF preview for EmoRES-TTS: Residual-Enhanced Vector Steering for Emotional Speech Generation
PASS ✓

EmoRES-TTS: Residual-Enhanced Vector Steering for Emotional Speech Generation

2026.09.29datacode

Kuan-Po Huang, Haohe Liu, Puyuan Peng, et al.

Imagine you're developing a text-to-speech system that needs to convey different emotions accurately, like happiness or sadness. Current methods often struggle with this because they require extensive retraining on emotion-labeled data, which is both time-consuming and resource-intensive. When using conventional approaches, like CoCoEmo, the system treats emotion vectors as fixed directions, which can lead to a lack of precision in expressing the desired emotion. This limitation is known as poor controllability, where the output doesn't align well with the intended emotional tone. To address this, the authors propose a new method called Emotion Residual-Enhanced Steering (EmoRES). The key insight is that emotion vectors can be broken down into two parts: a shared component that helps move speech away from a neutral tone and a residual component that fine-tunes the output toward the specific emotion requested. By controlling these components separately without needing to retrain the model, EmoRES significantly improves performance on various metrics, showing better adherence to the requested emotions and higher listener satisfaction. Compared to previous methods, this approach not only enhances the accuracy of emotional expression but also reduces the computational burden, making it a practical solution for developers in the field.

Novelty
8.0
Reliability
7.5
arxiv/2609.38157 →
PDF preview for Beyond the Timeline: Augmenting Long-Video Memory with Grounded Entity Biographies
PASS ✓

Beyond the Timeline: Augmenting Long-Video Memory with Grounded Entity Biographies

2026.09.29vision

Hui Ren, Lei Fan, Henry Pao, et al.

Imagine you're building a system that can answer questions about long videos, like a documentary or a day-long recording of events. The challenge is that objects in these videos can be hard to track; they might look similar or be described in the same way, leading to confusion about which object is which. This is problematic because when you ask a question about a specific object, the system might struggle to connect observations of that object across different parts of the video, resulting in incomplete or incorrect answers. This issue is known as identity resolution failure, where the system can't maintain a coherent 'biography' of the object in question. To tackle this, the authors propose a framework called Grounded Entity Biographies (GEB). The idea is to create a memory system that groups observations of the same physical object across different clips, allowing the system to retrieve a comprehensive biography of that entity when answering questions. By linking observations and maintaining context, GEB enables the model to follow an entity through various events, improving the accuracy of responses. Evaluations on several benchmarks, including long-duration recordings, show that GEB outperforms previous memory frameworks, achieving notable accuracy improvements, particularly on the EgoLifeQA dataset. This means that for builders, GEB offers a more reliable way to handle complex video data, making it easier to develop applications that require understanding and reasoning about long-term events.

Novelty
8.0
Reliability
7.5
arxiv/2609.38155 →
PDF preview for Thinking Before Thinking: Scaling Agentic Inference Through Meta-Reasoning
PASS ✓

Thinking Before Thinking: Scaling Agentic Inference Through Meta-Reasoning

2026.09.29agents

Paras Dahal, Anton Bakhtin, Taco Cohen, et al.

Imagine you're building an AI that needs to tackle complex, multi-step tasks, like coding or problem-solving. The challenge isn't just about generating a single correct answer; it's about managing the entire process — deciding what to build on, when to pivot, and how to leverage past work without losing context. Current systems often struggle with this, leading to issues like dropped context or poor decision-making when faced with new information or failures, which is what's called 'context loss' or 'decision fatigue.' To address these challenges, the authors propose a structured approach called agentic meta-reasoning. This method allows an AI to make explicit decisions about its next steps based on a compact summary of its ongoing work, rather than trying to recall everything it has done. By using a controller that assesses options and manages resources effectively, the AI can adapt its strategy in real-time. The results show that this approach significantly outperforms traditional direct control methods across various benchmarks, indicating that as tasks grow in complexity, having a structured decision-making process becomes crucial for success.

Novelty
8.0
Reliability
7.5
arxiv/2609.38147 →
PDF preview for Breaking the Uniformity Trap: Scaling Video Diffusion Model via SplitMoE
PASS ✓

Breaking the Uniformity Trap: Scaling Video Diffusion Model via SplitMoE

2026.09.29visioncode

Yu Xu, Yuxin Zhang, Xiao Yang, et al.

Imagine you're developing a system that generates videos, like creating animations or synthesizing scenes from text. The challenge lies in effectively managing the vast amount of visual information, especially when it comes to understanding the context and maintaining coherence across frames. Current methods often treat each piece of data independently, leading to a situation where related visual elements get scattered across different processing units, which is inefficient and can result in disjointed outputs. This issue is known as routing fragmentation, where the system fails to leverage the inherent relationships in the data, leading to a lack of structural integrity in the generated content. To tackle this, the authors propose a new architecture called SplitMoE, which organizes the processing units into two distinct roles: semantic experts that focus on high-level concepts and generic experts that handle the finer details of the visuals. This bifurcation allows the system to route information based on its semantic meaning rather than arbitrary balancing rules, which improves coherence and quality in video generation. By employing techniques like prototype-guided routing, SplitMoE not only enhances the efficiency of expert usage but also accelerates convergence during training. Compared to traditional methods, this approach offers a more intuitive way to scale video generation models, making it a valuable reference for future developments in the field.

Novelty
8.0
Reliability
7.5
arxiv/2609.38140 →
PDF preview for Stochastic World Models for Verifying Vision-Based Neural Feedback Systems
PASS ✓

Stochastic World Models for Verifying Vision-Based Neural Feedback Systems

2026.09.29vision

I. Samuel Akinwande, Mykel J. Kochenderfer, Clark Barrett

Imagine you're developing an autonomous vehicle that needs to make split-second decisions based on visual input. The challenge lies in ensuring that the system can accurately interpret its surroundings and respond appropriately, especially in critical situations like emergency braking. Current methods often rely on generative adversarial networks (GANs) to simulate these environments, but they tend to be bulky, produce unrealistic scenes, and are difficult to verify, leading to potential failures in real-world applications — this is what's called verification challenges. To address these issues, the authors propose using stochastic world models as a more effective alternative to GANs. These models are designed to capture the variability of sensor observations while remaining manageable for analysis. By training a world model with physically grounded latents, they achieve better fidelity in reproducing held-out frames compared to GANs, even with a significantly larger parameter count. Their verification procedure combines various analytical techniques to resolve previously unresolved state spaces, demonstrating that their approach can effectively enhance the reliability of vision-based systems in critical scenarios. This means that for builders working on autonomous systems, adopting these world models could lead to more robust and verifiable solutions than traditional GAN-based methods.

Novelty
8.0
Reliability
7.5
arxiv/2609.38120 →
PDF preview for ReCIRC: Rectified Conformal Risk Control
PASS ✓

ReCIRC: Rectified Conformal Risk Control

2026.09.29vision

Bruno Marcondes e Resende, Helton Graziadei, Thiago Rodrigo Ramos, et al.

Imagine you're developing a medical imaging tool that needs to accurately identify lesions in scans. The challenge lies in ensuring that the model doesn't miss critical areas while also not overwhelming users with false positives. Currently, many models use a single threshold for decision-making, which can lead to problems: it might be too lenient for easy cases, allowing errors, or too strict for difficult cases, resulting in missed detections. This is what's called a marginal guarantee, where the model's performance varies significantly based on the input's complexity. To address this, the authors propose a method called ReCIRC, which tailors the risk threshold for each input based on its estimated local risk. By reparameterizing the threshold as a risk budget, ReCIRC maintains the benefits of existing conformal risk control while allowing for more precise adjustments based on the input's characteristics. This means that when the risk estimates are accurate, the model can achieve nearly exact control over conditional risks, improving performance across various tasks like segmentation and classification. Compared to previous methods, ReCIRC not only retains the original guarantees but also enhances the model's ability to adapt to different scenarios, making it a more reliable tool for real-world applications.

Novelty
8.0
Reliability
7.5
arxiv/2609.38112 →
PDF preview for From Routing Signals to Selective Review: Visual regrounding in MoE VLMs
PASS ✓

From Routing Signals to Selective Review: Visual regrounding in MoE VLMs

2026.09.29vision

Hongzhu Guo, Mohsen Fayyaz, Nanyun Peng

Imagine you're building a vision-language model that needs to answer questions about objects in images, like their color or location. A common issue arises when the model confidently provides answers about objects that aren't even present in the image, leading to what’s known as a target-absence grounding failure. Current methods to address this often rely on analyzing the model's generated responses or its uncertainty, which can miss critical cues about the actual visual content. This is where the new approach comes in: by tapping into the internal routing decisions of Mixture-of-Experts (MoE) models, it detects when a target object is absent before generating an answer, allowing for a more informed response. The authors extract routing probabilities from specific models and train a linear detector to identify when to invoke a review prompt for better accuracy. This method not only improves the model's performance significantly on benchmark datasets but does so without altering the model's weights, making it a low-cost solution for enhancing reliability in real-world applications. Overall, this approach provides a way to utilize existing computation in MoE models to improve visual grounding, which is crucial for building more dependable AI systems.

Novelty
8.0
Reliability
8.0
arxiv/2609.38111 →
PDF preview for How Local Mixing Encodes Relative Position in Global NoPE Attention
PASS ✓

How Local Mixing Encodes Relative Position in Global NoPE Attention

2026.09.29scaling

Cutter Dawes, Nick Alonso, Tom Figliolia, et al.

Imagine you're building a language model that needs to understand the order of words in a sentence. Traditional transformer models use explicit position encodings to help with this, but they can struggle with longer sequences or when the context shifts. This is where methods like rotary position encoding (RoPE) come in, but they often assume that explicit encodings are necessary for success. However, recent approaches have shown that you can achieve good results without these encodings by using techniques like sliding window attention (SWA) and gated linear attention, which don't explicitly encode position in their global attention layers. This can lead to issues, such as losing track of the sequence order over long texts, which is known as the recency bias problem.  The authors propose that hybrid models, which combine local mixing layers with global attention, can implicitly maintain positional information through a recency bias in the residual stream. This means that even without explicit position encodings, these models can still effectively manage long sequences by leveraging the way they process information. By understanding how this recency bias works, builders can gain insights into designing models that can handle longer sequences more effectively, potentially leading to better performance in real-world applications.

Novelty
8.0
Reliability
7.5
arxiv/2609.38109 →
PDF preview for Do LLM Agents Execute the Plans They Declare? From Planning-Mode Declaration to Pattern-Specific Execution
PASS ✓

Do LLM Agents Execute the Plans They Declare? From Planning-Mode Declaration to Pattern-Specific Execution

2026.09.29agentscode

Subba Reddy Oota, Francisco Herrera, Jordi Cabot Sagrera, et al.

Imagine you're building an AI that needs to plan and execute tasks over a long period, like managing a project or navigating a complex environment. The challenge lies in ensuring that the AI not only chooses the right plan but also follows through effectively. Current systems often struggle because they can't clearly separate the planning phase from execution, leading to failures that are hard to diagnose — this is what's called the Plan Declaration–Execution Gap. When an AI generates a plan, it might not stick to it during execution, especially if the plan is lengthy or complex. This can result in a lack of coherence in the actions taken, which is frustrating when you're relying on the AI to get things done reliably.  To address this, the authors propose a method called Planning-as-Routing, where the AI first declares a specific planning mode — like Predefined, Sequential, Hierarchical, or Search — and then a router directs the task to the appropriate executor designed for that mode. Their findings show that using these pattern-specific executors significantly improves task success rates, especially in environments like ALFWorld and SWE-bench. While current LLMs still struggle with selecting the best planning mode for each task, the introduction of few-shot examples helps in some cases. This means that for anyone building AI systems, understanding how to effectively route tasks based on planning modes can lead to more reliable and successful outcomes.

Novelty
8.0
Reliability
7.5
arxiv/2609.38108 →
PDF preview for Telescopic Language Models
PASS ✓

Telescopic Language Models

2026.09.28scalingcommunity code

Zhilin Guo, Boqiao Zhang, Hakan Aktas, et al.

Imagine you're developing a language model that needs to perform well across different hardware setups, from powerful servers to mobile devices. Currently, if you want to optimize a model for each setup, you often have to train or compress a separate version for each one. This can lead to inefficiencies and wasted resources, especially when the model's performance varies significantly depending on the compute budget. This situation is what's called the 'fixed-exit' problem, where models are only trained to perform well at specific capacities, leaving them underperforming at others. To address this, the authors propose a Telescopic Language Model (TLM), which is designed to be flexible across a continuum of capacities. The TLM is trained using a method called stochastic prefix supervision, where it learns to predict the next token while being supervised at various depths of its architecture. This means that at every training step, the model can operate effectively at multiple levels of complexity without needing to change its structure. The results show that TLM can reduce the overall cost of training while maintaining performance across different tasks, outperforming fixed-exit models in efficiency and perplexity. For builders, this means you can deploy a single model that adapts to your needs without the overhead of multiple training runs.

Novelty
8.0
Reliability
7.5
arxiv/2609.35769 →
PDF preview for Learning Native Reflection in Unified Models with Interleaved Reinforcement Learning
PASS ✓

Learning Native Reflection in Unified Models with Interleaved Reinforcement Learning

2026.09.28multimodalcode

Yijia Fan, Ziqi Huang, Zhongang Cai, et al.

Imagine you're building a system that can generate and refine images based on user feedback. The challenge lies in ensuring that the model can effectively learn from its mistakes and improve its outputs over time. Current methods often rely on supervised fine-tuning or reinforcement learning that focuses on either the image generation or the feedback process separately. This can lead to missed opportunities for improvement, as the model may not fully leverage the information from both roles, resulting in what's known as inefficient credit assignment. To address this, the authors propose a method called UMM-Reflection, which allows the model to learn from multiple reflection trajectories simultaneously. By sharing an initial image across sibling trajectories, the model can compare different strategies for improvement and update its understanding of both the reflection tokens and the image revisions in a more integrated manner. This approach avoids the pitfalls of traditional methods by enabling credit to flow across multiple rounds of feedback, ultimately leading to better performance without needing an external verifier during inference. Compared to previous techniques, UMM-Reflection shows significant gains across various benchmarks, indicating a more effective way to refine multimodal outputs in real-world applications.

Novelty
8.0
Reliability
7.5
arxiv/2609.35767 →
preview unavailable
PASS ✓

Unifying Distributional Training for One-Step Visual Generation

2026.09.28vision

Chi Zhang, Haoyang Shi, Yueyi Liu, et al.

Imagine you're developing a system that generates images from text descriptions. The challenge lies in ensuring that the generated images not only look realistic but also accurately reflect the input descriptions. Current methods often struggle with this, leading to issues like mode collapse, where the model fails to capture the diversity of possible outputs, resulting in repetitive or low-quality images. This is what's called mode collapse, and it can severely limit the effectiveness of generative models in real-world applications. To address these challenges, the authors propose a new framework that separates the tasks of distribution modeling and matching discrepancies in generated features. This framework, called MGFlow, uses Gaussian mixtures to model feature distributions at different levels of granularity, allowing for more flexible and accurate image generation. By coupling mass-constrained sample assignments with updates to the model components, MGFlow effectively mitigates mode collapse, leading to significant improvements in performance on benchmarks like ImageNet. Compared to previous methods, MGFlow not only achieves state-of-the-art results but also enhances the capabilities of existing models, such as transforming a four-step text-to-image generator into a more efficient one-step process.

Novelty
8.0
Reliability
7.5
arxiv/2609.35763 →
PDF preview for Neural Harmonic Measure Operator
PASS ✓

Neural Harmonic Measure Operator

2026.09.28infracommunity code

Jinjin He, Sinan Wang, Yuchen Sun, et al.

Imagine you're working on a simulation that needs to solve complex equations for different shapes, like fluid flow around an object. Traditional methods often struggle with variable geometries, requiring extensive retraining whenever the shape or boundary conditions change. This can lead to inefficiencies and slowdowns, especially when dealing with real-time applications or complex simulations. The challenge is that the harmonic measure, which helps determine how solutions behave at the boundaries, is tightly linked to the geometry of the domain, making it hard to adapt without starting from scratch. This is what's called the retraining problem, where you lose time and resources every time you encounter a new shape or boundary condition. The Neural Harmonic Measure Operator (NHMO) addresses this by using a transformer-based approach to parameterize the harmonic measure, allowing it to adapt to different boundary values without needing retraining. By leveraging Walk-on-Spheres exit samples, NHMO can efficiently compute solutions for elliptic PDEs across various shapes. It even extends to Poisson problems, using a clever auxiliary network to handle corrections without the computational burden of traditional methods. Compared to previous approaches, NHMO not only outperforms four established baselines on a 3D benchmark but also competes well with leading neural operator methods in 2D. For builders, this means a more flexible and efficient tool for solving complex PDEs, saving time and computational resources while maintaining accuracy.

Novelty
8.0
Reliability
7.5
arxiv/2609.35752 →
PDF preview for How to Loop MoE: Flatten the Experts, Untie the Attention
PASS ✓

How to Loop MoE: Flatten the Experts, Untie the Attention

2026.09.28scalingcode

Shouren Wang, Chuang Ma, Mohsen Hariri, et al.

Imagine you're building a large language model that needs to efficiently use its resources while maintaining high performance. Current models often struggle with balancing the load across multiple experts, leading to underutilization of their capabilities. This is particularly evident in sparse mixture-of-experts (MoE) models, where only a few experts are activated for each input, which can limit their effectiveness. The challenge is to find a way to make better use of these experts without increasing the overall complexity of the model. This is what's called the load balancing problem. To address this, the authors propose a method called Foil, which combines the principles of looped transformers and MoE. The intuition behind Foil is to flatten the expert layers, allowing for more experts to be considered in each routing decision while maintaining a fixed number of parameters and compute. By untying the attention parameters for each pass, Foil enables more tailored routing decisions, leading to improved performance. The results show that Foil outperforms traditional looped models, achieving lower pretraining loss and better downstream accuracy, suggesting that a more flexible approach to expert usage can yield significant benefits. This means that for builders, adopting such a method could lead to more efficient models that leverage their resources more effectively.

Novelty
8.0
Reliability
7.5
arxiv/2609.35751 →
PDF preview for KV-streams for Efficient Compaction in Agentic Reinforcement Learning
PASS ✓

KV-streams for Efficient Compaction in Agentic Reinforcement Learning

2026.09.28scalingcode

Emiliano Penaloza, Dane Malenfant, Dheeraj Vattikonda, et al.

Imagine you're developing a large language model (LLM) that needs to remember long conversations or complex tasks. The challenge is that as the context length increases, fitting all that information into GPU memory becomes a bottleneck, slowing down training. Current methods often involve repeatedly filling the model's context, which can lead to inefficiencies and reduced throughput — this is what's called context compaction. When these strategies are overused, they can hinder the model's ability to learn effectively, as they may not utilize the available memory optimally. To address this, the authors propose a method called KV-streams, which allows for a more efficient way to manage the key-value cache used in LLMs. Instead of flushing the cache after each compaction, KV-streams stream the cache forward, maintaining a continuous flow of information. This not only speeds up training by 2.6 to 5 times but also allows the model to retain useful information over longer periods, acting almost like a recurrent state. Compared to previous work, this approach significantly enhances training throughput without sacrificing performance, making it a valuable addition for anyone looking to build more efficient LLMs.

Novelty
8.0
Reliability
7.5
arxiv/2609.35750 →
PDF preview for Copy the Same, Distill the Difference: Initializing Linear Vision Transformers
PASS ✓

Copy the Same, Distill the Difference: Initializing Linear Vision Transformers

2026.09.28vision

Huaiyuan Qin, Muli Yang, Gabriel James Goenawan, et al.

Imagine you're building a computer vision model that needs to process images efficiently. You might consider using Vision Transformers (ViTs), which have become popular for their ability to handle complex visual tasks. However, a challenge arises when trying to make these models more efficient: the traditional Softmax attention mechanism can be computationally expensive, and newer linear attention methods promise to reduce this cost. The problem is that while linear ViTs are designed to be more efficient, they often struggle to match the performance of their Softmax counterparts, especially when initialized from scratch. This is what's called the initialization problem, where starting from random weights can lead to suboptimal performance. To address this, the authors propose a method for transferring knowledge from Softmax ViTs to linear ViTs. They find that while the attention weights themselves are not directly transferable, the underlying learned representations in the MLP layers can be copied effectively. By distilling the attention behavior from Softmax models and combining it with the transferred MLP weights, linear ViTs can significantly improve their performance, even surpassing the original Softmax models in some cases. This approach not only enhances the efficiency of linear ViTs but also provides insights into how to leverage pre-trained weights across different model architectures, making it a valuable strategy for builders looking to optimize their vision models.

Novelty
8.0
Reliability
7.5
arxiv/2609.35745 →
PDF preview for Temporal Gradient Inversion for Private Trajectory Reconstruction in Embodied Reinforcement Learning
PASS ✓

Temporal Gradient Inversion for Private Trajectory Reconstruction in Embodied Reinforcement Learning

2026.09.24agentscommunity code

Sudip Bhujel, Shanghao Shi, Ruiquan Huang, et al.

Imagine you're developing an AI agent that learns from its environment, like a robot navigating a room. To improve its performance, it sends updates to a central server, but this process can unintentionally leak sensitive information about its actions and observations. Current methods focus on single frames of data, which can miss the bigger picture of how these frames relate over time — this is what's called temporal leakage. This can lead to serious privacy concerns, especially if someone can reconstruct the agent's entire experience from just the updates it sends. To address this, the authors propose a method that looks at the entire sequence of actions and observations, not just isolated moments. By analyzing the correlations between successive updates and the structure of the gradients, they can effectively reconstruct the agent's private data. Their method, TRACE, not only outperforms existing techniques in terms of speed and accuracy but also shows promise across various architectures and input types. For builders, this means that while developing agents, it's crucial to consider how temporal data can be protected, as traditional methods may not suffice.

Novelty
8.5
Reliability
8.0
arxiv/2609.30258 →
PDF preview for PoEM: Predicting RL Outcomes from Existing Policies
PASS ✓

PoEM: Predicting RL Outcomes from Existing Policies

2026.09.24alignment

Kimia Hamidieh, Giannis Daras, Antonio Torralba

Imagine you're developing a foundation model that needs to adapt to new tasks based on different reward signals, like following instructions or aligning with human preferences. Currently, if you want to change the reward function, you often have to retrain the model from scratch, which is not only time-consuming but can also lead to instability in the learning process. This is problematic because it limits flexibility and efficiency, especially when trying to combine multiple reward signals or adapt to new ones. This challenge is known as the inefficiency of reinforcement learning (RL) retraining. To address this, the authors propose a framework called PoEM, which allows you to predict the outcomes of RL for a new reward function without needing to run the RL training again. The key insight is that if the new reward can be expressed as a combination of existing rewards, the resulting policy can also be derived from the existing policies. Even when the rewards aren't linearly related, the authors found that the policies often lie in a low-rank subspace, making it possible to estimate the new policy using outputs from previously trained models. This approach not only saves computational resources but also provides a more stable way to adapt to new tasks. Compared to traditional methods, PoEM offers a more efficient path for building adaptable AI systems.

Novelty
8.0
Reliability
7.5
arxiv/2609.30226 →
preview unavailable
PASS ✓

TrackEverything: Long Horizon Dense Tracking via De-Duplicating 3D Scene Representations

2026.09.24visioncommunity code

Ayush Jain, Sreeharsha Paruchuri, Ishita Gupta, et al.

Imagine you're developing a system that needs to track multiple objects in a video, like a security camera monitoring a busy street. Current models struggle with a trade-off: they can either follow a few objects over long periods or track many objects but only for short clips. This limitation often leads to missed details or redundant data, which is frustrating when you need comprehensive insights from lengthy footage. This is what's called the tracking trade-off, where the model's effectiveness diminishes based on the duration and number of objects being tracked. TrackEverything offers a fresh perspective by treating videos as persistent 3D scenes, allowing it to track all visible points across extensive video lengths without the usual memory constraints. The approach is built on three key innovations: it uses a voxelization method to avoid duplicating tracks, separates the tracking process into refining endpoints and classifying points, and introduces a new sampling technique that reduces memory usage. Compared to previous models, TrackEverything not only tracks more points but also significantly outperforms existing dense trackers on shorter clips while maintaining competitive performance on longer sequences. For builders, this means a more efficient and comprehensive tracking solution that can handle complex scenes over extended periods.

Novelty
8.5
Reliability
7.5
arxiv/2609.30222 →
PDF preview for Underwater C3-JEPA: An Object-Centric Cross-View World Model for ROV Salvage
PASS ✓

Underwater C3-JEPA: An Object-Centric Cross-View World Model for ROV Salvage

2026.09.24vision

Yuncong Yang, Jinlong Li, Yulong Xue, et al.

Imagine you're working on an underwater robot designed to salvage heavy loads, but you can't rely on contact sensors to gauge your surroundings. Current methods often struggle with accurately predicting how the robot interacts with objects in the water, especially given the challenges posed by hydrodynamic lag and the need for precise control. This leads to issues like misjudging object positions or failing to adapt to changing conditions, which can be critical in salvage operations. This is what's called a lack of effective predictive modeling in complex environments. To address these challenges, the authors propose a new model called Underwater C$^{3}$-JEPA, which predicts how objects behave in a multi-view setting without needing direct contact. By encoding observations from multiple cameras and using control signals, the model creates a latent representation that captures the dynamics of the task. It employs techniques like weak binding for low-cost annotations and SIGReg for enhancing geometric accuracy. The results show that this model not only outperforms traditional methods in transferring relevant information for downstream tasks but also maintains a lightweight structure, making it suitable for real-time applications. This advancement means that builders can expect more reliable and adaptable underwater robots that can better handle the complexities of their environment.

Novelty
8.0
Reliability
7.5
arxiv/2609.30214 →
PDF preview for The Alignment Illusion in Multimodal Large Language Models
PASS ✓

The Alignment Illusion in Multimodal Large Language Models

2026.09.24multimodalcommunity code

Hong-Han Wang, Yuntao Wang, Hu Ding

Imagine you're building a multimodal AI that needs to understand both text and images, like a virtual assistant that can interpret photos and respond to questions about them. Currently, many researchers assume that if a model shows some alignment between visual and text representations, it means the model is effectively integrating these modalities. However, this can be misleading; for instance, when visual tokens are replaced with noise, the model's performance drops significantly, but traditional alignment measures fail to reflect this degradation accurately. This discrepancy is termed the alignment illusion, where the model's architecture inadvertently creates a false sense of similarity between visual and text inputs due to shared pathways in the model. To address this, the authors propose a new metric called the principal-angle gap, which better captures the true relationship between visual and text representations by focusing on their geometric properties rather than relying solely on scalar alignment scores. This approach reveals that the internal alignment in multimodal models is more about the geometry of the visual stream than a direct measure of content interaction. For builders, this means that relying on traditional alignment metrics could lead to misunderstandings about how well a model integrates different types of data, and that a more nuanced geometric perspective could provide deeper insights into model performance.

Novelty
8.0
Reliability
7.5
arxiv/2609.30210 →
PDF preview for ExplorationBench: Measuring AI Systems' Exploration in Verifiable Alien Worlds
PASS ✓

ExplorationBench: Measuring AI Systems' Exploration in Verifiable Alien Worlds

2026.09.24agentscode

Ming Zhang, Zhenghao Xiang, Peizhong Gao, et al.

Imagine you're developing an AI that needs to explore unknown environments, like a scientist testing new theories. The challenge lies in ensuring that the AI can generate genuinely new hypotheses rather than just recalling information it has seen before. Current benchmarks often fall short because they don't effectively measure the AI's ability to explore and learn in real-time, leading to issues like overfitting to familiar data or failing to adapt to new rules — this is what's called a lack of exploration capability. To address this, the authors created ExplorationBench, a framework that evaluates AI systems in controlled yet complex environments called Alien Worlds. These worlds have specific rules that can be tested, ensuring that the AI must truly explore and learn rather than rely on pre-existing knowledge. The benchmark includes two distinct sandboxes, AlienCode and AlienLogic, each designed to challenge the AI in different ways, providing feedback and tools to facilitate exploration. By evaluating various AI systems, the study reveals that while some can effectively learn and apply new rules, performance can vary significantly, highlighting the complexities of exploration. This work represents a significant step towards building AI that can genuinely discover and apply new knowledge in unfamiliar settings, which is crucial for real-world applications.

Novelty
8.5
Reliability
7.5
arxiv/2609.30199 →
PDF preview for SAGE: Mitigating Long-Horizon Reasoning Biases via Topological Guidance
PASS ✓

SAGE: Mitigating Long-Horizon Reasoning Biases via Topological Guidance

2026.09.24reasoningcode

Xinyue Zeng, Jiawei Zhang, Yujun Yan, et al.

Imagine you're building a large language model that needs to solve complex problems over many steps, like planning a project or navigating a tricky conversation. The challenge is that these models often get stuck in local patterns that seem reasonable but lead to poor outcomes. This is known as exploration bias, where the model favors paths that aren't actually the best, and compounding bias, where small mistakes add up over time, making it hard to find the right solution. These biases can severely limit the model's ability to reason effectively over long horizons, especially when rewards are sparse. To tackle these issues, the authors propose a new framework called SAGE, which stands for Structural Admissibility-Guided Exploration. The idea is to provide the model with structural guidance that helps it navigate the reasoning space more effectively. SAGE uses two main techniques: algebraic sparsification, which helps the model focus on more promising paths by filtering out less relevant options, and hyperbolic structural guidance, which embeds reasoning states in a way that encourages better exploration. By applying these methods, SAGE shows significant improvements across various benchmarks, including a remarkable eight-fold increase in performance on a challenging real-world task. This means that for builders, SAGE could lead to more reliable and effective AI systems capable of tackling complex, long-term reasoning tasks.

Novelty
8.0
Reliability
7.5
arxiv/2609.30192 →
PDF preview for Nonequilibrium Phases of Repulsive Self-Attention: Chaos, Attention Condensation, and Emergent Locality
PASS ✓

Nonequilibrium Phases of Repulsive Self-Attention: Chaos, Attention Condensation, and Emergent Locality

2026.09.23scaling

Qucheng Gao, Zuyi Yang, Xiao Chen

Imagine you're building a sophisticated AI that needs to understand and adapt to complex patterns over time, like predicting user behavior or managing resources dynamically. Current models often struggle with maintaining coherence in their attention mechanisms, leading to issues like losing track of important information or failing to adapt to new inputs. This is particularly evident in scenarios where the model's attention becomes too rigid or overly focused, which can result in what's called attention collapse, where the model fails to respond effectively to changes in context. To address these challenges, the authors investigate a minimal recurrent transformer model that incorporates a unique feedback mechanism. By using a negative value map and similarity-based attention, they create a system where tokens can dynamically reorganize their representations based on their interactions. This leads to fascinating behaviors, such as the emergence of chaotic dynamics and clustering phenomena, which allow the model to maintain a flexible and adaptive attention mechanism. Compared to traditional approaches, this method not only enhances the model's ability to handle complex temporal patterns but also introduces the concept of attention condensation, where attention can remain diffuse yet effective even as the number of tokens increases. For builders, this means that there are new avenues to explore in designing AI systems that require sustained attention and adaptability, potentially leading to more robust applications in real-world scenarios where context and dynamics are constantly shifting.

Novelty
8.5
Reliability
7.0
arxiv/2609.28448 →
PDF preview for Repairability of Inexact Solvers in Recursive State Estimation with Machine Learning
PASS ✓

Repairability of Inexact Solvers in Recursive State Estimation with Machine Learning

2026.09.23infra

Yanjun Ji, Dennis Willsch, Orkun Şensebat, et al.

Imagine you're working on a system that needs to estimate the state of a dynamic process, like managing a power grid. In practice, these systems often rely on recursive state estimation methods, which can struggle when local corrections don't translate into better overall performance. This can lead to issues like overconfidence in predictions or failure to adapt to changing conditions, which are known as local admissibility failures. These failures can stem from inaccuracies in the model or the way corrections are applied, leading to what’s called gain drift — where the adjustments made to improve accuracy actually worsen the estimates over time. To address these challenges, the authors propose a framework that characterizes how to apply corrections within a defined budget while ensuring that the overall system remains stable. They introduce a method that separates the errors from the corrections, allowing for a more nuanced understanding of how local adjustments impact the overall estimation process. By linking these local corrections to a broader understanding of error propagation, they provide a way to certify the effectiveness of both classical and quantum approaches to state estimation. This means that for builders working on systems that require reliable state estimation, especially in complex environments, this framework offers a practical way to enhance performance without compromising the integrity of the underlying models.

Novelty
8.0
Reliability
7.5
arxiv/2609.28425 →
PDF preview for Quantum score matching with applications to learning thermal states
PASS ✓

Quantum score matching with applications to learning thermal states

2026.09.23data

Yulong Dong, Jiaqi Leng

Imagine you're trying to develop a quantum AI that can learn from complex quantum states, like those found in quantum physics. Traditional methods for generative learning rely on evaluating probabilities, which can be tricky when dealing with quantum systems due to their unique properties, such as noncommuting density operators. This noncommutativity complicates the task of defining scores for learning and poses challenges in creating efficient training methods. These issues can lead to failures in accurately learning from quantum data, which is what we call the problem of quantum score matching. To address this, the authors propose a new framework that adapts the principles of score matching to the quantum realm, providing a way to learn from quantum Gibbs states without the need for complex thermal-state preparations. Their approach not only offers theoretical guarantees but also shows promising results in practical applications, even when faced with limited measurement resources. By demonstrating effectiveness on IBM quantum hardware, they highlight that this method can significantly reduce errors in Hamiltonian parameters, making it a viable option for real-world quantum learning tasks. This advancement opens up new possibilities for building quantum AI systems that can learn more effectively from quantum data.

Novelty
8.5
Reliability
7.5
arxiv/2609.28391 →
PDF preview for Memory-Conditioned Diffusion Model for Generalized Langevin Dynamics
PASS ✓

Memory-Conditioned Diffusion Model for Generalized Langevin Dynamics

2026.09.23data

Minglei Yang, Sicheng He

Imagine you're trying to model complex systems where the future state depends not just on the current state but also on a history of past states. This is particularly challenging in fields like physics or finance, where systems can exhibit long-term dependencies and intricate behaviors. Traditional methods often struggle because they either require a lot of historical data or fail to capture the nuances of these dependencies, leading to what's called 'memory loss' — where important past information is ignored or inadequately represented. This can result in poor predictions and a lack of adaptability in dynamic environments. To address these challenges, the authors propose a memory-conditioned diffusion method that learns how to predict future states based on both current observations and a compact representation of past states. Instead of needing to define a complex memory kernel or reconstruct all unresolved variables, this method uses a bank of exponential filters that can efficiently store and update relevant historical information. This allows for effective predictions over various time scales without the burden of long observation windows. The approach is further enhanced by a kernel-based score estimator that generates samples for training a neural flow map, making it suitable for autoregressive simulations. Compared to previous methods, this approach offers a more efficient way to handle long-memory retention and complex dynamics, which could be particularly useful for builders working on predictive models in uncertain environments.

Novelty
8.0
Reliability
7.5
arxiv/2609.28371 →
PDF preview for FleXray: Universal Clinical X-ray Segmentation
PASS ✓

FleXray: Universal Clinical X-ray Segmentation

2026.09.22visioncode

Victor Ion Butoi, Vivek Gopalakrishnan, John V. Guttag, et al.

Imagine you're a doctor relying on X-ray images to diagnose patients. While X-rays are widely used, they often obscure important anatomical details due to the 2D nature of the images, making it hard to identify structures accurately. This limitation means that creating large, annotated datasets for training AI models is impractical, which is a problem known as data scarcity. As a result, many AI systems struggle to generalize across different anatomical regions, leading to errors in segmentation and analysis. This is what's called the lack of quantitative analysis in X-ray imaging. To address this, the authors developed FleXray, a model that generates fully-annotated 2D X-ray images from existing 3D CT data. By simulating diverse X-ray appearances and anatomical variations, FleXray can train on a rich dataset without the need for extensive manual labeling. This approach not only improves segmentation accuracy for 60 anatomical structures but also allows for automated measurements that can assist in disease grading and enhance navigation during X-ray-guided procedures. Compared to previous methods that relied on limited datasets, FleXray opens up new possibilities for quantitative analysis in clinical settings, making it a valuable tool for healthcare professionals.

Novelty
8.5
Reliability
8.0
arxiv/2609.26756 →
PDF preview for The Sirens' Song: When Proximal Background Context Overshadows Distant Evidence
PASS ✓

The Sirens' Song: When Proximal Background Context Overshadows Distant Evidence

2026.09.22alignmentcode

Xiaoyu Yang, Jie Lu, Wei Duan, et al.

Imagine you're building a long-context language model that needs to pull in relevant information from a vast amount of text. The challenge isn't just about how far away that information is; it's often about how much irrelevant information is competing for attention right next to it. This issue, known as the Proximity Trap, can lead to models missing out on valuable distant evidence because they get overwhelmed by nearby, less relevant details. Current approaches mainly focus on overcoming the distance, but they don't adequately address this competition from proximal context. To tackle this, LYRA introduces a method that reshapes how context is retrieved, directing more attention to the most relevant information while still keeping track of where everything is located in the text. This is achieved through a t-distributed directional matching mechanism that aligns relevance more effectively. The authors also present ProxBench, a new benchmark designed to evaluate how well models utilize distant evidence in the presence of distracting nearby information. Compared to previous work, LYRA not only improves the retrieval of relevant information over longer contexts but also provides a more nuanced way to assess model performance in real-world scenarios where irrelevant context can interfere. For builders, this means better tools for developing models that can effectively sift through large amounts of data and focus on what truly matters.

Novelty
8.0
Reliability
7.5
arxiv/2609.26718 →
PDF preview for When are bosonic Gaussian states classical to learn?
PASS ✓

When are bosonic Gaussian states classical to learn?

2026.09.22data

Senrui Chen, Antonio Anna Mele, Francesco Anna Mele, et al.

Imagine you're developing a system that needs to understand and predict behaviors in both quantum and classical realms, like in advanced sensing technologies. Currently, learning from quantum systems, especially bosonic Gaussian states, is complex and often requires more data than learning from classical systems. This is problematic because it limits the efficiency and applicability of quantum technologies in real-world scenarios, particularly when trying to bridge the gap between quantum and classical information processing. The authors approach this challenge by examining the conditions under which these quantum states can be learned with fewer samples, akin to classical Gaussian distributions. They find that cold Gaussian states, which are close to the vacuum state, require significantly more data to learn than their classical counterparts, while warm Gaussian states, influenced by thermal fluctuations, can be learned with a sample complexity that matches classical learning. This insight not only provides a clearer understanding of the quantum-to-classical transition but also has practical implications for designing better quantum sensors and learning algorithms.

Novelty
8.0
Reliability
8.0
arxiv/2609.26705 →
PDF preview for Beyond Repeated Sampling: Learning Search Policies for LLM Reasoning
PASS ✓

Beyond Repeated Sampling: Learning Search Policies for LLM Reasoning

2026.09.22reasoning

Ismail Labiad, Matthieu Kowalski, Marc Schoenauer, et al.

Imagine you're building a language model that needs to solve complex reasoning tasks, like advanced math problems. Currently, many models rely on a method called naive repeated sampling, where they generate multiple answers independently and hope one is correct. This often leads to many similar answers that don't explore the problem space effectively, which is a limitation known as local decoding noise. It means that while you might get a lot of attempts, they often don't provide the variety needed to tackle difficult questions. This is what's called ineffective exploration. To address this, the authors propose a method that first generates a range of relevant concepts or strategies before producing an answer. This approach allows the model to explore the problem space more meaningfully by conditioning the answer generation on these diverse concepts. They even take it a step further by training a small concept generator using reinforcement learning, optimizing it to produce concepts that enhance the performance of a larger, fixed answer generator. The results show that this trained generator significantly improves the model's ability to solve challenging problems compared to traditional methods, even outperforming larger models that weren't specifically tuned for the task. For builders, this means there's potential to create more effective AI systems that can reason better by leveraging a structured exploration of ideas.

Novelty
8.0
Reliability
7.5
arxiv/2609.26704 →
preview unavailable
PASS ✓

GameHorizon Suite: Multi-Horizon Data and Evaluation in Gameplay

2026.09.21agents

Yiran Wang, Xingyilang Yin, Junfu Pu, et al.

Imagine you're developing an AI that can play video games like a human, understanding complex instructions and adapting to different gameplay scenarios. The challenge lies in the current benchmarks, which often focus on a limited set of games or lack the depth needed to evaluate real gameplay skills. This leads to issues like not capturing the nuances of long-term planning or the ability to follow multi-step instructions, which are crucial for success in dynamic environments. This is what's called a lack of comprehensive evaluation. To fill this gap, the authors created GameHorizon, a unified suite that includes a large-scale dataset of gameplay recordings, an automated annotation system for multi-horizon instructions, and a benchmark for testing AI models in both offline and online settings. By evaluating 47 different models with over a million invocations, they reveal a clear hierarchy of task difficulty and model performance. This approach not only standardizes how we assess AI in gaming but also provides valuable insights for developers looking to build more capable agents.

Novelty
8.0
Reliability
7.5
arxiv/2609.25001 →
PDF preview for Rare Event Estimation via Iterative Unalignment
PASS ✓

Rare Event Estimation via Iterative Unalignment

2026.09.21agentscode

Hanming Yang, Daksh Mittal, Jing Dong, et al.

Imagine you're developing an AI agent that operates autonomously, making decisions based on its actions. One of the biggest challenges is ensuring that the agent can handle extremely rare but potentially catastrophic events, like a miscalculation leading to a failure in a critical task. Current methods, like naive Monte Carlo simulations, struggle with this because they require immense computational resources to explore the vast number of possible action trajectories. This is what's called the combinatorial explosion problem, where the number of scenarios grows exponentially with the complexity of the agent's actions. As a result, estimating the likelihood of these rare events becomes impractical, leaving a gap in safety and reliability for deployed agents. To address this, the authors propose a new importance sampling method that modifies the agent's model weights to create a more efficient proposal distribution for estimating these probabilities. This approach allows for gradient-based optimization, balancing the need for accurate event amplification with the stability of the estimator. By evaluating their method on large-scale models and a variety of rare events, they achieve significant efficiency improvements over traditional methods, making it feasible to assess risks that were previously too rare to estimate reliably. For builders, this means a more robust way to ensure the safety of autonomous agents in real-world applications, where understanding the risks of rare failures is crucial.

Novelty
8.5
Reliability
8.0
arxiv/2609.24969 →
PDF preview for An Interpretable Memory Decision Controller for LLM Agents Based on Three-Signal Complementarity: Decoupling Confidence and Consistency
PASS ✓

An Interpretable Memory Decision Controller for LLM Agents Based on Three-Signal Complementarity: Decoupling Confidence and Consistency

2026.09.18agentscommunity code

Yiming Zhang, Jinghong Zhang, Haoran Zhao, et al.

Imagine you're building a large language model that needs to pull in information from a memory store to generate responses. The challenge arises when this memory contains conflicting information; the model might blindly use these memories, leading to hallucinations or incorrect outputs. This issue is particularly pronounced in retrieval-augmented generation (RAG) systems, where the model's reliance on potentially unreliable memories can amplify errors, creating a situation where the model's outputs are less trustworthy than if it had no memory at all. This phenomenon is known as hallucination, where the model generates false or misleading information based on the conflicting memories it retrieves. To address this, the authors propose a Memory Decision Layer (MDL), which acts as a filter between memory retrieval and response generation. The MDL evaluates the trustworthiness of retrieved memories by considering their relevance, reliability, and the risk associated with using them. It employs a geometric approach to create a decision representation that helps the model determine when to trust a memory and when to abstain from using it altogether. This method not only reduces the hallucination rate significantly—by over 56% in general scenarios—but also approaches zero in high-risk situations. Compared to previous methods, the MDL is efficient, requiring no additional training and operating much faster than traditional evaluation methods, making it a practical solution for builders looking to enhance the reliability of language models.

Novelty
8.5
Reliability
8.0
arxiv/2609.22043 →
PDF preview for COMPLEX: A Closed-Form Certified Embedding of Multiparameter Persistence Modules
PASS ✓

COMPLEX: A Closed-Form Certified Embedding of Multiparameter Persistence Modules

2026.09.18data

Sushovan Majhi, Atish Mitra, Žiga Virk, et al.

Imagine you're working on a machine learning model that needs to accurately represent complex data structures, like those found in multiparameter persistence. The challenge lies in ensuring that the features extracted from this data are not only informative but also reliable for making predictions. Traditionally, methods have focused on upper bounds for these features, which can lead to issues where the extracted information doesn't faithfully represent the underlying data, resulting in poor performance in real-world applications. This is what's called a lack of 'faithfulness' in the features, making it hard to trust the model's predictions. To address this, the authors propose a new method called COMPLEX, which introduces a closed-form embedding for multiparameter modules. By slicing the module and embedding each slice using a certified mapping, they create a framework that provides both upper and lower bounds for the feature representation. This dual approach allows for a measurable sense of faithfulness, ensuring that the features maintain their integrity across different predictions. The results are promising, with COMPLEX achieving state-of-the-art performance on various benchmarks, outperforming existing methods, including those based on transformers and graph-based approaches. For builders, this means a more reliable way to handle complex data structures, leading to better-performing models in practical applications.

Novelty
8.5
Reliability
8.0
arxiv/2609.22012 →
PDF preview for Coding Agents with an Obstacle-Aware Harness for Safe Robot Manipulation
PASS ✓

Coding Agents with an Obstacle-Aware Harness for Safe Robot Manipulation

2026.09.17agents

Bingxin Xu, Yuzhang Shang, Zhen Dong, et al.

Imagine you're building a robot that needs to navigate around obstacles while completing tasks, like picking up objects without bumping into anything. Current coding agents can write their own controllers, but they often ignore safety constraints, leading to collisions with obstacles. This is a significant issue because while the agents can achieve their goals, they do so at the expense of safety, which is critical in real-world applications. This failure is primarily due to the planning phase, where the agents don't adequately prioritize avoiding obstacles, resulting in frequent accidents. The problem is compounded by the lack of a mechanism to replan routes when obstacles are detected. To address this, the authors propose SafeHarness, which equips the agents with two new strategies: one for planning routes that consider obstacles and another for executing contact actions that avoid them. With these enhancements, SafeHarness achieves a 71.9% success rate in task completion and an 87.5% rate of avoiding collisions, significantly outperforming previous state-of-the-art methods. For builders, this means that integrating safety into robot coding agents is now more feasible, allowing for more reliable and practical applications in real-world scenarios.

Novelty
8.0
Reliability
7.5
arxiv/2609.20822 →
PDF preview for JEPA-Anything: Learning Predictive Models across Different Worlds
PASS ✓

JEPA-Anything: Learning Predictive Models across Different Worlds

2026.09.17reasoning

Taoyong Cui, Zhongyao Wang, Xinyue Xu, et al.

Imagine you're developing an AI that needs to understand and predict complex interactions in various fields, from biology to weather systems. The challenge lies in creating models that can generalize across these different domains without being overly specialized. Traditional predictive models often fail when applied outside their training context, leading to poor performance in real-world scenarios — this is what's called domain specificity. They struggle to adapt when faced with new types of data or unexpected situations, which can result in inaccurate predictions and missed opportunities for intervention. To address this, JEPA-Anything proposes a framework that leverages orthogonal predictive factorization (OPF). This approach allows the model to break down complex predictions into simpler, complementary factors that can be learned independently and then recombined. By doing so, it enhances the model's ability to generalize across various domains, as demonstrated through extensive evaluations in areas like vision, clinical trajectories, and molecular dynamics. Compared to previous models, JEPA-Anything not only improves prediction accuracy but also supports experimental interventions, bridging the gap between theoretical modeling and practical applications. For builders, this means a more robust tool for creating AI systems that can operate effectively in diverse and dynamic environments.

Novelty
8.5
Reliability
8.0
arxiv/2609.20800 →
PDF preview for Harm Laundering in GPT Models: Evidence That Gender Discrimination Is Transformed Rather Than Reduced Across Safety-Trained Generations
PASS ✓

Harm Laundering in GPT Models: Evidence That Gender Discrimination Is Transformed Rather Than Reduced Across Safety-Trained Generations

2026.09.17alignment

Sarah Wyer, Sue Black, Noura Al Moubayed

Imagine you're developing a large language model to assist with sensitive topics, like mental health or social issues. You'd want to ensure that the model doesn't perpetuate harmful stereotypes or discriminatory content. Currently, many evaluations focus on surface-level toxicity scores, which can misleadingly suggest that a model is safe when it might still be transforming harmful narratives rather than eliminating them. This is what's called harm laundering, where the underlying issues are masked by changes in language that appear benign on the surface. For instance, while earlier models might have produced harmful content directed at women, later versions seem to correct this but instead shift the focus to men, creating new forms of representational harm. This means that while toxicity scores drop, the actual harm can persist or even grow in different forms. The authors propose a new framework to identify and address this issue, emphasizing the need for a more nuanced understanding of model outputs. By formalizing harm laundering and providing a detection protocol, they offer a way to better assess the true impact of generative models, which is crucial for anyone building applications that rely on these technologies.

Novelty
8.5
Reliability
7.5
arxiv/2609.20779 →
PDF preview for Tables Decoded: DELTA for Structure, TARQA for Understanding
PASS ✓

Tables Decoded: DELTA for Structure, TARQA for Understanding

2026.09.15visioncode

Jahanvi Rajput, Dhruv Kudale, Saikiran Kasturi, et al.

Imagine you're building a system that needs to understand and interact with tables in documents, like extracting data from financial reports or answering questions about survey results. Currently, many solutions rely on vision-language models that analyze images of tables, which can struggle with accuracy and scalability, especially in multilingual contexts. This often leads to issues like misinterpreting cell contents or failing to recognize the layout correctly, which is what's called table reconstruction failure. Additionally, these models can be cumbersome to adapt for different languages due to their reliance on visual encoders that are not language-agnostic. To address these challenges, a new approach leverages structured textual representations instead of images. This method, called DELTA, separates the tasks of recognizing physical and logical structures in tables and uses Optical Character Recognition (OCR) to accurately extract both layout and content. The output is in a compact format known as Optimised Table Structure Language (OTSL), which aligns well with large language models (LLMs). The results show that DELTA achieves competitive scores on table structure recognition benchmarks and performs robustly on non-English tables. Furthermore, by fine-tuning an LLM on OTSL sequences, the authors introduce TARQA, which significantly improves performance on table visual question answering tasks. This shift towards structured text representation means that developers can build more efficient and adaptable systems for handling tables across various languages and formats.

Novelty
8.0
Reliability
7.5
arxiv/2609.17458 →
PDF preview for Evaluating Verified Autonomy in Quantum Engineering
PASS ✓

Evaluating Verified Autonomy in Quantum Engineering

2026.09.15agents

Naixu Guo, Changhao Li, Siyu Cheng, et al.

Imagine you're working on quantum technologies, where the goal is to harness complex quantum phenomena for practical applications. As these quantum systems become more intricate, managing them requires a lot of human oversight and coordination. Currently, researchers often rely on manual processes to plan experiments and analyze results, which can lead to inconsistencies and errors — this is what's called human error in high-stakes environments. The challenge is that existing AI agents haven't been rigorously tested in real-world quantum settings, leaving a gap in our understanding of their reliability. To address this, the authors created Quantum-Harbor, a virtual lab that allows AI agents to interact with quantum systems in a controlled way. This setup not only lets researchers verify the actions taken by these agents but also the conclusions they draw from their experiments. They also introduced QIQCBench, a benchmark consisting of 49 expert-designed tasks that cover various aspects of quantum engineering, such as calibration and error correction. By evaluating 17 different AI systems, they found significant variability in performance, highlighting the difference between theoretical capability and practical reliability. This work lays the groundwork for future advancements in autonomous quantum engineering, providing a clearer path for building trustworthy AI systems in this field.

Novelty
8.0
Reliability
7.5
arxiv/2609.17439 →
PDF preview for GPU-CFR: 80x Faster Counterfactual Regret Minimization by Compiling the Game to Static Dataflow and CUDA Graph Replay
PASS ✓

GPU-CFR: 80x Faster Counterfactual Regret Minimization by Compiling the Game to Static Dataflow and CUDA Graph Replay

2026.09.10infracode

Boning Li, Longbo Huang

Imagine you're developing an AI that plays complex games, like poker or chess, where it needs to evaluate countless possible moves and outcomes. Traditionally, these calculations are done on CPUs, which can handle the workload efficiently, but as the complexity increases, the performance of GPU implementations has lagged behind due to overhead from launching kernels and managing data. This is what's called inefficiency in GPU utilization, where the potential speed of GPUs isn't fully realized because of the way the computations are structured and executed. To address this, the authors propose GPU-CFR, a system that compiles the game logic into a static format before any calculations begin. By precomputing the necessary data and structuring the operations in a way that minimizes the need for frequent framework interactions, GPU-CFR can execute iterations much faster. The results are striking: it runs 29.8 to 80.4 times faster than previous GPU implementations and even outperforms optimized CPU versions significantly. This means that for developers working on AI for games, GPU-CFR offers a much more efficient way to handle complex decision-making processes without changing the underlying algorithms.

Novelty
8.5
Reliability
8.0
arxiv/2609.11923 →
PDF preview for Artificial Id: Drive and Persistent Alignment in Agentic AI
PASS ✓

Artificial Id: Drive and Persistent Alignment in Agentic AI

2026.09.10agents

Yakov Pyotr Shkolnikov

Imagine you're building an AI that needs to operate across various tasks without losing track of its goals or adapting to changes in its environment. Current systems often rely on external specifications for behavior, like setting objectives or stopping rules, which can lead to issues when the context shifts or when the AI encounters unexpected situations. This reliance can result in failures such as misalignment, where the AI's actions don't match the intended goals, or unintended behaviors that persist because the system lacks a way to adaptively manage its state across tasks. This is what's called the control problem in AI systems. To address this, the paper introduces the idea of an 'artificial id,' which acts as an internal mechanism that helps the AI decide when to continue, stop, or change its behavior based on its own experiences rather than relying solely on external instructions. In a simple virtual experiment, a small controller learns to adapt its actions through a process called differential persistence, which allows it to develop useful control strategies even without explicit task objectives. This approach suggests that adaptive agency can emerge organically, but it also highlights the risks of misalignment and unintended consequences if the system's internal state isn't properly managed. For builders, this means that creating AI systems with a persistent internal drive could lead to more robust and adaptable agents that can handle real-world complexities better than current models.

Novelty
8.5
Reliability
7.0
arxiv/2609.11911 →
preview unavailable
PASS ✓

3D Point Splatting for mmWave Radar Novel View Synthesis

2026.09.10vision

Adnan Armouti, Yixuan Gao, Rajalakshmi Nandakumar

Imagine you're working on a system that needs to create realistic images from radar data, like for autonomous vehicles or surveillance. Current methods struggle because they either simplify the physics too much or can't handle the complexity of multi-view scenarios. For instance, some techniques use learned features that ignore important physical properties, leading to less accurate representations of the radar signals. This is what's called a loss of fidelity, which can be critical in applications where precision matters. To address these challenges, the authors propose a new method called 3D Point Splatting (3DPS). This approach directly applies the radar equation to create a renderer that maintains physical accuracy while being able to handle multiple viewpoints. Each point in the 3D space is treated with a specific material model, allowing for complex outputs that are not tied to any specific radar product. This means that the same optimized scene can be used across different radar formats without needing to retrain the model. Compared to existing optical methods, 3DPS shows a significant improvement in performance, achieving a mean Pearson correlation that is substantially higher than its predecessors. For anyone building radar systems, this means you can expect better accuracy and flexibility in your applications, making it easier to integrate radar data into real-world scenarios.

Novelty
8.5
Reliability
8.0
arxiv/2609.11894 →
PDF preview for Augustinian BabyLM: What Ostensive Definition Can and Cannot Teach a Small Language Model
PASS ✓

Augustinian BabyLM: What Ostensive Definition Can and Cannot Teach a Small Language Model

2026.09.10visioncode

Lisa Bylinina

Imagine you're developing a language model that needs to understand words not just from text but also from images. Typically, these models start with random word meanings, which means they have to learn everything from scratch based on the text they see. This can lead to gaps in understanding, especially for words that are visually rich or context-dependent. For instance, a model might struggle with the nuances of words like 'banana' without any visual context, which is where the approach in this paper comes in. By initializing word embeddings with visual information from images that correspond to those words, the model can retain a clearer understanding of their meanings throughout training. This method, inspired by St. Augustine's idea of learning through observation, shows that visual grounding can leave a lasting imprint on the model's performance. However, while this visual initialization helps in specific tasks, it doesn't seem to improve performance on standard benchmarks that focus on abstract grammatical knowledge. The research highlights that the benefits of visual grounding are particularly evident in tasks related to object properties, suggesting a nuanced approach to training language models that could be more effective in real-world applications. For builders, this means that incorporating visual context into language models could lead to better understanding and performance in specific scenarios, even if traditional benchmarks don't fully capture these improvements.

Novelty
8.0
Reliability
7.0
arxiv/2609.11870 →
PDF preview for RetroThinker: Enabling Retrospective Thinking in Speech LLMs
PASS ✓

RetroThinker: Enabling Retrospective Thinking in Speech LLMs

2026.09.10agents

Yi-Jen Shih, Puyuan Peng, Abdelrahman Mohamed, et al.

Imagine you're building a voice assistant that needs to understand and respond to users in real-time, like during a conversation. Current systems often struggle with complex reasoning tasks, especially when they have to process speech and text simultaneously. This leads to issues like misinterpretation of user intent or delayed responses, which can frustrate users. This is what's called the accuracy-latency trade-off, where improving one often worsens the other. To address this, a new approach called RetroThinker has been developed, which allows a speech model to revise its reasoning as it listens and responds. By combining supervised fine-tuning with a method that optimizes for preference based on the length of reasoning, RetroThinker can correct its thought process on the fly. This means that while the user is speaking, the model can adjust its responses to be more accurate without significantly increasing latency. Compared to previous models, RetroThinker achieves an 11% absolute accuracy gain while maintaining similar response times, making it a promising option for real-time applications.

Novelty
8.0
Reliability
7.5
arxiv/2609.11864 →
PDF preview for ConvMem: Convolutional Memory for Long-Context Reasoning
PASS ✓

ConvMem: Convolutional Memory for Long-Context Reasoning

2026.09.09reasoning

Hongming Zhang, Zhaozhen Gu, Fengshuo Bai, et al.

Imagine you're building a chatbot that needs to understand long conversations or documents. Traditional large language models (LLMs) can struggle with this because they have fixed limits on how much text they can process at once. When they try to handle long contexts, they often break down, leading to issues like losing track of important details or generating irrelevant responses. This is particularly problematic in scenarios where the conversation or text spans multiple segments, as existing methods like MemAgent can be slow and prone to overfitting due to their reliance on reinforcement learning training. To tackle these challenges, ConvMem offers a fresh perspective by treating the reasoning process as a hierarchical convolution, similar to how convolutional neural networks (CNNs) operate. Instead of processing text in a linear fashion, ConvMem organizes it into a tree structure, allowing for faster and more efficient reasoning. It employs techniques like Configurable Strides and Skip Connections to enhance the model's ability to capture and propagate relevant information, while Multi-Kernel Convolution helps break down complex queries into manageable parts. This approach not only reduces the risk of errors but also allows for significant parallel processing, making it more efficient than previous methods. Compared to earlier work, ConvMem provides a more scalable and effective solution for handling long contexts without the drawbacks of traditional training methods.

Novelty
8.0
Reliability
7.5
arxiv/2609.10441 →
PDF preview for Forgetting Only What Matters: Layer-Selective Unlearning toward Robust LLMs
PASS ✓

Forgetting Only What Matters: Layer-Selective Unlearning toward Robust LLMs

2026.09.09datacode

Ravi Ranjan, Olivera Kotevska, Agoritsa Polyzou

Imagine you're developing a large language model that needs to forget certain sensitive information without losing its overall performance. Currently, when models are trained, they can inadvertently memorize and reproduce undesirable content, which raises privacy and safety concerns. The common solution is to retrain the model, but this can be inefficient and may not effectively erase the unwanted knowledge, especially when the model undergoes changes like quantization. This is what's called the 'forgetting-utility trade-off', where the model's ability to forget conflicts with its performance on tasks it should still handle well. To address this, a new approach called Forgetting Only What Matters via Unlearning Layers (FOM-UL) is proposed. Instead of applying broad updates across the entire model, FOM-UL selectively targets specific transformer layers based on their significance to the information being forgotten. This means that only the layers that are crucial for the unwanted content are updated, while the rest of the model remains intact. As a result, FOM-UL not only improves the effectiveness of forgetting but also maintains the model's utility, even under conditions like post-training quantization. Compared to existing methods, FOM-UL shows better performance in suppressing memorization while preserving the model's ability to perform on retained tasks.

Novelty
8.0
Reliability
7.5
arxiv/2609.10439 →
PDF preview for TANGO: Humanoid Navigation in Cluttered Environments with a Whole-Body Vision-Language-Action Model
PASS ✓

TANGO: Humanoid Navigation in Cluttered Environments with a Whole-Body Vision-Language-Action Model

2026.09.08agentscode

Anqi Li, Yuxin Chen, Zhaobo Li, et al.

Imagine you're building a humanoid robot that needs to navigate through a crowded room filled with furniture and obstacles. Traditional navigation methods often rely on 2D path planning, which can lead to issues when the robot encounters complex 3D environments. For instance, a robot might get stuck or collide with objects because it doesn't adapt its movements to the three-dimensional space around it. This is what's called a failure in whole-body adaptation, where the robot struggles to coordinate its arms, torso, and legs effectively. To address this, TANGO offers a fresh approach by combining vision and language to guide the robot's movements. Instead of just following a flat path, TANGO allows the robot to understand natural language instructions and make real-time adjustments based on what it sees. It predicts joint-space actions for its entire body, enabling it to navigate through cluttered environments smoothly. The training process occurs entirely in simulation, where diverse movement behaviors are synthesized, ensuring the robot learns to avoid collisions and adapt its actions dynamically. Compared to previous methods, TANGO not only shows superior performance in simulated environments but also successfully operates in real-world scenarios without needing prior training on actual navigation data. This means that for builders, TANGO represents a significant step forward in creating robots that can understand and navigate complex spaces using human-like instructions.

Novelty
8.0
Reliability
7.5
arxiv/2609.09158 →
PDF preview for ReCite: Agentic Reasoning for Faithful Citation
PASS ✓

ReCite: Agentic Reasoning for Faithful Citation

2026.09.08agentscode

Yuyang Huang, Bobo Li, Jiajia Song, et al.

Imagine you're writing a research paper and need to cite relevant studies to support your arguments. With the sheer volume of literature available, it can be overwhelming to find the right papers that not only exist but also logically back up your claims. Currently, many systems rely on finding papers that are semantically similar to your text, but this often leads to misattributions — citing real papers that don’t actually support your argument. This is what's called misattribution, and it can undermine the credibility of your work. To tackle this issue, a new framework called ReCite has been proposed. Instead of just looking for similar papers, ReCite focuses on understanding the specific claims being made and finding evidence that directly supports them. It does this by employing a method that involves reasoning about the claims and verifying whether the evidence aligns logically. This approach not only improves the accuracy of citations but also introduces a self-correction mechanism that helps refine the results when the initial candidates don’t fit well. Compared to existing generative models, ReCite shows a significant improvement in citation accuracy, making it a more reliable tool for anyone looking to automate academic writing.

Novelty
8.5
Reliability
7.5
arxiv/2609.09156 →
PDF preview for Procedural Graphs: Self-Evolving Execution Structures for LLM Agents
PASS ✓

Procedural Graphs: Self-Evolving Execution Structures for LLM Agents

2026.09.08agents

Yuxing Lu, Yicheng Chen, Shanchan Wu, et al.

Imagine you're building an AI assistant that needs to manage complex tasks over time, like scheduling meetings or coordinating projects. The challenge is that as tasks become more intricate, agents often lose track of what they should do next, leading to mistakes like using the wrong tool or repeating actions that don't help. This is what's called losing context or procedural drift, which can severely hinder performance in real-world applications. Current methods typically rely on simple memory systems that don't effectively guide agents through these long sequences of actions. They often lack a structured way to represent the knowledge of what to do and when to do it. To address this, the authors propose the Procedural Graph, a framework that organizes procedural knowledge into a graph structure. This allows agents to reference a network of procedures, helping them make informed decisions at each step. The graph evolves as the agent learns from both successful and failed attempts, refining its structure to improve future performance. This self-evolving aspect means that agents can adapt their strategies without needing constant manual updates. Compared to traditional memory-based approaches, the Procedural Graph consistently outperforms them, providing a more robust solution for building agents that can navigate complex tasks effectively.

Novelty
8.0
Reliability
7.5
arxiv/2609.09153 →
PDF preview for Copying explains the collective behavior of AI agents in the wild
PASS ✓

Copying explains the collective behavior of AI agents in the wild

2026.09.08agents

Giordano De Marzo, Nicola Albore, David Garcia

Imagine you're developing AI agents that need to collaborate without prior instructions or memory. In many cases, these agents struggle to coordinate effectively, leading to confusion and inefficiency. This is particularly evident when they operate in environments where they must make decisions based on limited information, which can result in inconsistent actions and missed opportunities for cooperation. This phenomenon is often referred to as coordination failure, where agents fail to align their actions due to a lack of shared context or understanding of their environment. In response to this challenge, the authors explore how a group of AI agents utilized a public wiki to help each other during a timed test. Each agent, with a lifespan of about an hour and no memory, made decisions based on the visible content around them. They found that agents tended to mimic the options they observed, leading to a collective behavior that was surprisingly organized. By analyzing the agents' choices, they developed minimal models that explain how these decisions create a coherent structure among the agents, demonstrating that simple copying behavior can lead to effective coordination. This insight suggests that understanding the visibility of information can significantly enhance the design of collaborative AI systems, making them easier to guide and more effective in real-world applications.

Novelty
8.0
Reliability
7.5
arxiv/2609.09150 →
PDF preview for NOAH: Learning the Full Patient Journey. A Longitudinal Multimodal Time-Aware Model for Representation and Forecasting
PASS ✓

NOAH: Learning the Full Patient Journey. A Longitudinal Multimodal Time-Aware Model for Representation and Forecasting

2026.09.08multimodal

Tobias Susetzky, Raphael Rehms, Dmitrii Seletkov, et al.

Imagine you're a healthcare provider trying to understand a patient's journey through the healthcare system. You have access to a wealth of data — medical images, lab results, and clinical notes — but piecing it all together to predict future health outcomes is a daunting task. Current AI models often fall short because they focus on specific types of data or treat time in a simplistic way, which can lead to missed insights and inaccurate forecasts. This is what's called a lack of holistic understanding of patient dynamics. They struggle with the irregularities and complexities of real-world data, making it hard to provide personalized care based on a patient's unique history and future risks. To address these challenges, NOAH offers a fresh approach by using a generative transformer model that can handle diverse data types and capture the intricate temporal relationships in patient records. It integrates information bidirectionally over time and employs a variational latent space to model the continuous evolution of patient states. This means it can not only forecast future health outcomes but also simulate different clinical scenarios and classify conditions without needing extensive retraining. Compared to previous models, NOAH provides a more comprehensive and adaptable framework for understanding patient trajectories, which could significantly enhance predictive systems in personalized medicine and improve patient care outcomes.

Novelty
8.5
Reliability
7.5
arxiv/2609.09140 →
PDF preview for Co-Evolving Harnesses and Models: On-Policy Correction Helps Weaker Models Catch Up Where Imitation Fails
PASS ✓

Co-Evolving Harnesses and Models: On-Policy Correction Helps Weaker Models Catch Up Where Imitation Fails

2026.09.08agents

Zhou Yu, Bin Bi, Shiva Kumar Pentyala, et al.

Imagine you're building an AI agent that needs to perform specific tasks in a business setting, like managing customer inquiries or processing data. The challenge lies in ensuring that the agent not only understands the tasks but also adapts to the context and tools available. Current methods often rely on fine-tuning models or using advanced architectures, but they can struggle when the model's training doesn't align with the evolving context of the tasks, leading to issues like poor tool selection or inability to recover from errors — this is what's called model-harness misalignment. To tackle this, the authors propose a method that evolves the agent's operational framework, or harness, while also incorporating expert feedback. The idea is to first develop a harness using a simpler model, which can then be effectively utilized by a more advanced model. However, they found that simply training the weaker model on expert trajectories could backfire, causing performance drops. Instead, they introduce an on-policy expert-correction pipeline that allows the weaker model to maintain its original planning style while benefiting from expert guidance, thus preserving the compatibility between the model and the harness. This approach not only enhances performance but also provides a structured way to evolve both the model and its operational context together, which is crucial for real-world applications.

Novelty
8.0
Reliability
7.5
arxiv/2609.09134 →
PDF preview for ExecCritic: Learn to Test, Test to Improve for Coding Agents
PASS ✓

ExecCritic: Learn to Test, Test to Improve for Coding Agents

2026.09.08agentscode

Leitian Tao, Baolin Peng, Haorui Wang, et al.

Imagine you're developing an AI that can automatically fix bugs in software repositories. The challenge lies in ensuring that the tests used to validate these fixes accurately reflect the intended behavior of the code. Often, when an AI generates both the patch and the test, they can share the same mistakes, leading to a false sense of confidence in the solution. This situation is known as test-induced bias, where the tests fail to catch errors because they are not independently verified. To address this, ExecCritic introduces a structured approach that separates the roles of test generation and code repair. It employs two distinct agents: a Test agent that creates tests independently and a Repair agent that revises the code based on feedback from those tests. This separation allows for more reliable test construction, as the Test agent focuses solely on generating valid tests, while the Repair agent learns to improve code based on the execution results of those tests. The results show that using high-quality tests significantly improves the success rate of code repairs, demonstrating a clear advancement over previous methods that did not utilize this role separation.

Novelty
8.0
Reliability
7.5
arxiv/2609.09133 →
preview unavailable
PASS ✓

UniMate: One Unified Model to Animate Diverse Skeletons

2026.09.04visioncommunity code

Linzhan Mou, Jiahui Lei, Zhiyang Dou, et al.

Imagine you're creating a video game and need to animate characters with different body structures. Traditionally, animators rely on specific templates for each character type, which can be time-consuming and limits creativity. This approach often leads to issues like needing to fine-tune animations for each unique skeleton or using reference motions that may not fit well, which is what's called template rigidity. As a result, animators face bottlenecks when trying to produce diverse and dynamic movements efficiently. To address these challenges, the authors developed UniMate, a unified foundation model that generates motion for any skeleton based on a 3D asset and a simple text prompt. The model leverages a topology-aware diffusion transformer that incorporates skeletal structure into its attention mechanisms, allowing it to understand and generate movements that are contextually appropriate for various body types. This means animators can create animations without the need for extensive retraining or optimization for each new character. Compared to previous methods, UniMate not only enhances the quality and efficiency of motion generation but also supports innovative features like zero-shot transfer across different skeleton types and text-guided editing, making it a significant step forward for creators in the animation space.

Novelty
8.5
Reliability
8.0
arxiv/2609.05415 →
PDF preview for RegionFed: Federated Learning for Personalized Query Understanding in Heterogeneous Retail Environments
PASS ✓

RegionFed: Federated Learning for Personalized Query Understanding in Heterogeneous Retail Environments

2026.09.04data

Quoc H. Nguyen, Ali Lafzi, Abhijeet Phatak, et al.

Imagine you're building a retail search system that needs to cater to different regions, each with its own unique preferences and query styles. The challenge is that while federated learning (FL) can help protect user privacy by training models across devices, traditional FL methods often create a single global model that doesn't perform well for specific regions. This is particularly problematic when using modern transformer models, which can struggle significantly under these conditions, leading to poor accuracy. This issue is known as model collapse, where the model fails to adapt to the diverse data it encounters. To tackle this, the authors propose RegionFed, a federated learning framework that operates at the gradient level rather than the parameter level. This means it can effectively diagnose the differences between regional and global data and adaptively choose the best personalization strategy for each region without compromising performance. By treating models as black boxes, RegionFed can be applied to various architectures like T5 and RoBERTa without any code changes. The results are promising, showing significant accuracy improvements across multiple datasets while maintaining strong privacy guarantees. For builders, this means a more effective way to deploy personalized models in diverse environments without sacrificing user privacy.

Novelty
8.0
Reliability
7.5
arxiv/2609.05403 →
PDF preview for Same Trajectory, Contradictory Rewards (ROBORMBENCH): Paraphrase Fragility in Vision Language Reward Models
PASS ✓

Same Trajectory, Contradictory Rewards (ROBORMBENCH): Paraphrase Fragility in Vision Language Reward Models

2026.09.04vision

Wonje Jeung, Sangyeon Yoon, Hyesoo Hong, et al.

Imagine you're developing a robotic system that learns from human instructions to perform tasks. You want it to understand that different ways of saying the same thing should lead to the same actions. However, current vision-language models (VLMs) often struggle with this; they can give wildly different feedback based on how a goal is phrased. This inconsistency can lead to situations where the same robot behavior is deemed a failure in one context and a success in another, which is problematic for reliable learning. This issue is known as paraphrase instability, where slight changes in wording can significantly alter the predicted outcomes of robot actions. To address this, the authors created ROBORMBENCH, a comprehensive benchmark that includes thousands of real robot trajectories and a wide range of paraphrased instructions. By analyzing how different VLMs respond to these variations, they found that many models are prone to this instability, especially with more complex rewrites. They also discovered that training dedicated reward models with trajectory-grounded supervision can lead to much more stable performance. This work emphasizes that ensuring paraphrase robustness is essential for building reliable VLM-based reward systems in robotics, which is crucial for developers aiming to create effective and adaptable robotic agents.

Novelty
8.0
Reliability
7.5
arxiv/2609.05401 →
PDF preview for When LLM Decompilers Recompile More and Preserve Less
PASS ✓

When LLM Decompilers Recompile More and Preserve Less

2026.09.04infra

Chang Liu, Edward Raff, Kristopher Micinski

Imagine you're a security engineer trying to analyze software for vulnerabilities. You rely on decompilers to convert compiled code back into a high-level language, but traditional tools often leave you with incomplete or non-executable pseudocode. This can lead to situations where a decompiled function appears to work perfectly in tests but fails under real-world conditions, missing critical vulnerabilities or behaving unexpectedly. This is what's called 'divergence' — where the decompiled output doesn't match the original code's behavior despite passing all tests. To tackle this issue, a new approach called Decompile-Diverge was developed. Instead of relying on fixed tests, it creates dynamic drivers that generate a fuzzing corpus based on the original function. This allows for a more thorough examination of the decompiled code's behavior across various inputs, revealing discrepancies that traditional methods might miss. The results show that even when decompilers achieve high recompilability rates, they can still diverge significantly in behavior, highlighting the importance of this new method. For builders, this means that relying solely on recompilability metrics can be misleading. Decompile-Diverge provides a more reliable way to ensure that decompiled code behaves as expected, which is crucial for security applications where undetected vulnerabilities can have serious consequences.

Novelty
8.5
Reliability
8.0
arxiv/2609.05370 →
PDF preview for Design Docs Are All You Need: An AI-native Machine-Learning Performance Tool
PASS ✓

Design Docs Are All You Need: An AI-native Machine-Learning Performance Tool

2026.09.04infra

Samuel Kushnir, Kimia Noorbakhsh, Kavya Sreedhar, et al.

Imagine you're developing a machine learning system that needs to adapt quickly to new models and frameworks. The challenge is that as ML evolves, the underlying assumptions of your performance models often become outdated, leading to a constant cycle of refactoring and technical debt. This is particularly problematic because traditional coding practices can be cumbersome and slow, making it hard to keep up with rapid advancements in the field. This situation is what's called tech debt, where the cost of maintaining and updating code becomes higher than starting anew. To address this, the authors propose SMART, a performance-modeling library that relies on natural-language design documents instead of conventional code. The idea is that these documents serve as self-contained guides that coding agents can use to regenerate the necessary code whenever updates are needed. By focusing on step-by-step examples and a minimal operator intermediate representation, SMART allows for reliable regeneration of implementations that closely match established reference models. This means that rather than wrestling with outdated code, builders can focus on maintaining clear, understandable documentation that evolves alongside their systems, making the design process more efficient and less error-prone.

Novelty
8.5
Reliability
8.0
arxiv/2609.05364 →
PDF preview for The History Is the Detector: Executing CVE Patch History, End-to-End
PASS ✓

The History Is the Detector: Executing CVE Patch History, End-to-End

2026.09.04infra

Qiushi Wu, Kevin Eykholt, Youngja Park, et al.

Imagine you're a developer trying to ensure your software is secure from known vulnerabilities. You might rely on public databases that list software flaws, but these records are often designed for human review, not for automated systems. This means that even if a flaw is documented, similar unsafe conditions could still exist in your code without any alerts, leading to potential security risks. This situation is what's called a gap in automated vulnerability detection. To address this, the authors propose a framework called BUGSTONE-E2E, which takes historical vulnerability data and converts it into executable rules for detecting flaws. The idea is to mine fixing commits from past vulnerabilities to create reusable detection rules, organizing them by type and programming language. The process involves a multi-stage pipeline that starts with lightweight analysis to filter out benign code before applying more complex models to the remaining candidates. This method not only identifies potential vulnerabilities but also generates patches that can be validated through rigorous testing. Compared to previous approaches, BUGSTONE-E2E effectively leverages historical data to create a systematic workflow for vulnerability detection and repair. This means that developers can now automate the identification and fixing of vulnerabilities based on past incidents, significantly improving the security posture of their software without relying solely on manual inspection.

Novelty
8.0
Reliability
7.5
arxiv/2609.05335 →
PDF preview for RoboSPA: Can VLA Models Go Beyond Simple Scenes and Short-Horizon Tasks?
PASS ✓

RoboSPA: Can VLA Models Go Beyond Simple Scenes and Short-Horizon Tasks?

2026.09.04agentscode

Zhenxuan Fan, Bo Zhang, Yutong Lin, et al.

Imagine you're developing a robot that can manipulate objects in a complex environment, like a kitchen. The challenge isn't just getting the robot to pick up a cup; it's about understanding where the cup is in relation to other objects, planning a sequence of actions to reach it, and adapting if something goes wrong. Current benchmarks often test robots in overly simplified scenarios, which means they miss critical failures in real-world situations, such as misjudging distances or forgetting steps in a multi-part task. This is what's called limited evaluation scope. To address these shortcomings, the authors created RoboSPA, a comprehensive dataset and benchmark designed to evaluate how well vision-language-action models can handle intricate spatial reasoning and long-term planning. RoboSPA includes a variety of tasks that increase in difficulty, allowing for a more nuanced assessment of a robot's capabilities. By introducing new diagnostic metrics beyond just success rates, RoboSPA helps identify specific areas where current models struggle, such as understanding complex spatial relationships and executing detailed plans. For anyone building robots, this benchmark offers a more realistic framework for testing and improving their systems, pushing the boundaries of what these agents can achieve in real-world applications.

Novelty
8.0
Reliability
7.5
arxiv/2609.05324 →
PDF preview for Clean Engineering, Unstable Measurement: A Preregistered Reliability Failure of Black-Box LLM Observers on Shared Endpoints
PASS ✓

Clean Engineering, Unstable Measurement: A Preregistered Reliability Failure of Black-Box LLM Observers on Shared Endpoints

2026.09.03infra

Haoyaun Zhu, Jie Zhang

Imagine you're developing a language model that needs to consistently generate accurate responses based on user queries. You might assume that if you ask the same question today and tomorrow, the model will give you the same answer. However, this paper reveals that this assumption often fails in practice. In two large-scale audits involving nearly 53,000 requests, the consistency of rankings for identical queries was significantly lower than expected, with Spearman correlations falling short of the required thresholds. This inconsistency can arise from various factors, including biases in how labels are interpreted and noise in the model's output that can lead to different rankings even for the same input. These issues are termed 'measurement instrument failures' and highlight the fragility of relying on model names as stable indicators of performance. To address these challenges, the authors propose a structured approach that includes a three-level snapshot-identity ladder and a set of design rules for better evaluation practices. They emphasize the importance of measuring a model's performance before making any assumptions about its reliability. This work shifts the focus from simply trusting model outputs to critically assessing the conditions under which those outputs are generated, which is crucial for anyone building applications that depend on consistent and reliable AI behavior.

Novelty
8.0
Reliability
7.5
arxiv/2609.04198 →
PDF preview for A Common Measure of Communication for Speech Brain-Computer Interfaces
PASS ✓

A Common Measure of Communication for Speech Brain-Computer Interfaces

2026.09.02datacode

Dulhan Jayalath, Benjamin Ballyk, Oiwi Parker Jones

Imagine you're working on a device that helps people with paralysis communicate by translating their brain activity into speech. The challenge is that different systems use various datasets and methods, making it hard to compare their effectiveness. For instance, one system might report high accuracy, but that could be misleading if it only recognizes a limited vocabulary. This situation is what's called a measurement problem, where the reported scores don't truly reflect a user's ability to communicate their intended speech. To address this, the authors propose a new metric called open-vocabulary mutual information (OVMI). This metric measures how much information a speech BCI can convey based on a reference distribution of words that a user might want to communicate. By using OVMI, systems can be evaluated on a common scale, allowing for fair comparisons even when they operate under different conditions. The authors found that optimizing vocabulary based on OVMI can lead to significant improvements in accuracy, showing that this approach not only clarifies how systems perform but also guides better vocabulary design for future developments. Overall, this work provides a structured way to assess and compare speech BCIs, which could lead to more effective communication aids for those in need.

Novelty
8.0
Reliability
7.5
arxiv/2609.02887 →
PDF preview for Graph Machine: Towards Better Pretraining via Edges
PASS ✓

Graph Machine: Towards Better Pretraining via Edges

2026.09.02infra

Lintai Hou

Imagine you're building a large-scale AI model that needs to process vast amounts of data efficiently. Traditional architectures often struggle with state management, either becoming too rigid with fixed-size states or too inefficient with static routing, leading to performance bottlenecks. This is particularly problematic when trying to scale models while maintaining speed and accuracy, which can result in what's called 'state explosion' or 'routing inefficiency.' These issues can hinder the model's ability to adapt and learn from new information effectively. The Graph Machine (GM) architecture addresses these challenges by employing a dynamic routing mechanism that allows for sparse access to a state that grows linearly with the input size. Instead of being limited to a fixed number of connections, GM uses pointer-like objects that can be updated in a differentiable manner, enabling more flexible and efficient data retrieval. By replacing a significant portion of the dense layers in a Transformer model with these sparse layers, GM maintains performance while reducing computational overhead. The results indicate that even with a limited number of tokens retrieved per layer, the model's performance remains robust, showcasing a slight improvement in loss metrics compared to traditional methods. This approach marks a meaningful shift in how we can design architectures for large-scale models, allowing builders to create more efficient systems that can handle larger states without sacrificing performance. For those developing AI solutions, GM offers a promising pathway to enhance scalability and adaptability in complex tasks.

Novelty
8.0
Reliability
7.5
arxiv/2609.02881 →
PDF preview for GRADSOLVE: fast exact gradients for ODE ensembles on GPUs
PASS ✓

GRADSOLVE: fast exact gradients for ODE ensembles on GPUs

2026.09.02infracode

Alessio Spurio Mancini

Imagine you're working on a simulation that relies on ordinary differential equations (ODEs) to model complex systems, like weather patterns or mechanical systems. You need to adjust parameters and see how those changes affect the outcomes, which requires calculating derivatives of the ODE solutions. Currently, the tools available for this task force you to choose between speed and the ability to differentiate: the fastest solvers can't provide gradients efficiently, while those that can are much slower. This trade-off can be frustrating when you're trying to optimize your models or run simulations at scale. The approach taken here is to create a library called GRADSOLVE, which allows you to solve ODE ensembles and compute their gradients efficiently on NVIDIA GPUs. It does this by recording the steps taken by an adaptive solver and then differentiating a fixed-step replay of those steps, which is much faster than traditional methods. GRADSOLVE not only runs significantly faster than existing solvers like DiffEqGPU.jl but also computes gradients much more quickly once a record is established. This means that for anyone building simulations that require frequent adjustments and optimizations, GRADSOLVE could save a lot of time and computational resources compared to previous methods.

Novelty
8.0
Reliability
8.0
arxiv/2609.02876 →
PDF preview for Post-Training Language Models for Gold-Medal Performance in Coding Competitions
PASS ✓

Post-Training Language Models for Gold-Medal Performance in Coding Competitions

2026.09.02agents

Aleksander Ficek, Sean Narenthiran, Mehrzad Samadi, et al.

Imagine you're developing an AI that can solve complex programming challenges, like those found in international competitions such as the IOI and ICPC. Currently, many AI systems struggle with the intricacies of problem-solving in these high-stakes environments, often failing to adapt their strategies or generate diverse solutions. This is particularly evident when they encounter novel problems or need to refine their approaches based on feedback, leading to what's known as performance stagnation or lack of adaptability. To address these challenges, the authors propose a comprehensive pipeline that includes large-scale problem curation, synthetic reasoning traces, and a combination of supervised fine-tuning and reinforcement learning. They introduce a unique strategy called GenCorrect, which allows the AI to iteratively generate and refine solutions based on real-time feedback. This results in significant performance improvements, with their models achieving scores that not only surpass established benchmarks but also exceed those of top human competitors in the IOI. For builders, this means a more robust framework for developing AI systems capable of tackling complex, real-world programming tasks effectively.

Novelty
8.5
Reliability
8.0
arxiv/2609.02849 →
PDF preview for Facet-0: A Robotic Foundation Model for Contact-Rich Precise Manipulation
PASS ✓

Facet-0: A Robotic Foundation Model for Contact-Rich Precise Manipulation

2026.09.01agentscode

Haoyuan Deng, Haichao Liu, Wenkai Guo, et al.

Imagine you're building a robot to assemble tiny parts with extreme precision, like in electronics manufacturing. Current methods often struggle with the nuances of contact interactions, leading to failures when the robot misjudges how its actions will affect the parts. This is what's called contact failure, where the robot might apply too much force or misalign components, resulting in poor assembly outcomes. Traditional approaches typically rely on rigid programming or basic feedback loops, which don't adapt well to the complexities of real-world tasks. Facet-0 addresses these challenges by predicting the consequences of its actions in a more sophisticated way. It combines multimodal representation learning with reinforcement learning to create a model that understands both the physical interactions and the visual context of the assembly task. By using a causal history of actions and aligning it with visual and kinematic data, the robot can better anticipate the effects of its movements. This leads to a significant improvement in success rates for assembly tasks, achieving 82% success compared to just 15% for the best existing methods, all while maintaining high accuracy and low latency. For builders, this means a more reliable and adaptable robotic system that can handle complex assembly tasks with greater confidence.

Novelty
8.5
Reliability
7.5
arxiv/2609.01596 →
PDF preview for SUN: Persistent Programs For Language-Grounded Control-to-Learning-to-Real Policies
PASS ✓

SUN: Persistent Programs For Language-Grounded Control-to-Learning-to-Real Policies

2026.08.31agents

Weiqi Wang, Zhi Li, Yudong Lei, et al.

Imagine you're building a robot that needs to perform complex tasks, like assembling furniture or navigating a cluttered room. The challenge lies in ensuring that the robot not only follows commands but also understands the context and objectives of its actions. Currently, many systems rely on hand-crafted rewards and simplistic policies that often lead to suboptimal performance, especially in long-horizon tasks. This can result in behaviors that drift away from the intended goals, a problem known as reward hacking or misalignment. To address this, the authors propose a system called Kuafu, which uses Semantically UNified Programs. This approach allows for the definition of geometric and contact relationships in a way that can be directly translated into control objectives and learning rewards. By leveraging large vision-language models, Kuafu can automatically generate these programs from natural language descriptions and scene semantics. This means that the robot can learn to perform tasks without needing extensive demonstrations or manually defined rewards. In tests across nine different tasks, Kuafu significantly outperformed traditional methods, achieving higher success rates and more efficient trajectory generation. This shift towards integrating symbolic planning with data-driven execution could fundamentally change how we approach robotic learning and control.

Novelty
8.5
Reliability
7.5
arxiv/2608.31167 →
PDF preview for PaperGym: Rubric-Centered Evolution for Research-Plan Generation
PASS ✓

PaperGym: Rubric-Centered Evolution for Research-Plan Generation

2026.08.31rlhfcode

Yuhan Wang, Zhengxi Lu, Yuchen Yan, et al.

Imagine you're trying to develop an AI that can autonomously plan and execute research projects. The challenge lies in the fact that research planning is inherently subjective, lacking clear, verifiable answers. Current reinforcement learning methods struggle because they often rely on tasks that don't provide a reliable critic, leading to issues like criterion leakage where the AI can earn rewards through mere paraphrasing rather than genuine understanding. This is what's called criterion leakage, and it undermines the learning process. To address this, the authors propose PaperGym, a framework that turns research papers into comprehensive training environments. By extracting questions from the research goals and criteria from the methods and experiments, PaperGym creates a structured approach that minimizes leakage and enhances the learning experience. The framework uses a two-step training process, leveraging the rubric both as context and as a reward signal. Compared to existing datasets, PaperGym shows a significant reduction in criterion leakage and outperforms traditional supervised fine-tuning across multiple benchmarks. For builders, this means a more reliable way to train AI systems that can understand and innovate in research contexts, ultimately leading to better performance in real-world applications.

Novelty
8.0
Reliability
7.5
arxiv/2608.31119 →
PDF preview for Overcoming critical slowing down in frustrated spin systems by learned multiscale sampling
PASS ✓

Overcoming critical slowing down in frustrated spin systems by learned multiscale sampling

2026.08.31infra

Gabriele Bandini, Giulio Biroli, Patrick Charbonneau, et al.

Imagine you're working on a simulation of a complex physical system, like a spin model, where interactions can lead to frustrating configurations that slow down your computations. Traditional methods, like cluster algorithms, excel in many scenarios but struggle when faced with even slight frustration, leading to what's known as critical slowing down. This means that as you approach a critical point, the algorithms take longer and longer to converge, making them inefficient for practical use. This is a significant hurdle when trying to model real-world systems accurately and efficiently. To tackle this issue, the authors propose a new approach that learns the relevant clusters instead of constructing them. They introduce the wavelet conditional renormalization group (WCRG) method, which samples the probability distribution of fluctuations in a frustrated two-dimensional model. By recursively generating configurations from coarse to fine scales, WCRG maintains efficiency, achieving a sampling complexity of O(log2 L), which is a marked improvement over standard local MCMC methods. This method not only reproduces key statistical properties of the system but also clarifies the tradeoff between sampling speed and the model's expressiveness, providing a more robust solution for simulating frustrated systems.

Novelty
8.5
Reliability
7.5
arxiv/2608.31114 →
PDF preview for Aspire: Can Models Self-Evolve from Vague Goals?
PASS ✓

Aspire: Can Models Self-Evolve from Vague Goals?

2026.08.31agentscode

Yuhao Wu, Jingyuan Zhang, Jiajun Shi, et al.

Imagine you're trying to help an AI learn and improve over time, but instead of giving it specific tasks, you just tell it to 'become a better researcher.' The challenge here is that without clear objectives, the AI has to figure out what that means, how to assess its own progress, and what data to use for learning. Current methods often rely on predefined tasks and metrics, which can limit the AI's ability to adapt and grow in a meaningful way. This is what's called a lack of flexibility in learning, where the AI might optimize for the wrong goals or fail to recognize its own shortcomings. To address this, the authors propose ASPIRE, a benchmark that allows AI agents to evolve based on vague goals. Instead of being given explicit tasks, the agents receive a natural-language capability goal and must determine how to interpret that goal, select appropriate data, and decide when to evaluate their progress. This approach encourages a more exploratory learning process, where agents can adapt their strategies based on their interpretations of the goals. However, the results indicate that while agents can complete training loops, their improvements at the weight level are inconsistent and often do not translate to better performance on hidden evaluations. This means that while ASPIRE offers a new way to think about AI learning, there are still significant challenges to overcome in ensuring that agents can effectively learn and improve in real-world scenarios.

Novelty
8.0
Reliability
7.0
arxiv/2608.31111 →
PDF preview for Cross-Regional Grapevine Cold Hardiness Prediction via Learned Multimodal Latent Representations
PASS ✓

Cross-Regional Grapevine Cold Hardiness Prediction via Learned Multimodal Latent Representations

2026.08.31data

William Solow, Paola Pesantez-Cabrera, Markus Keller, et al.

Imagine you're a farmer in a region where freezing temperatures can damage your crops, and you need to know how resilient your plants are to the cold. Currently, farmers rely on various models to predict cold hardiness, but these models often work well only in specific areas where they were trained. This limitation means that if you move to a new region or grow a different cultivar, the predictions can be unreliable, leading to potential crop losses. This is what's called a lack of transferability in predictive models, which is a significant issue in agriculture, especially in areas with limited data on cold hardiness. To tackle this problem, the authors propose a framework that learns a transferable representation of cold hardiness by capturing the unique characteristics of different regions through embeddings. By using text descriptions of the plants and historical data, the model can make predictions even in areas where it hasn't been trained before, supporting both zero-shot and few-shot learning. This means that farmers can get more accurate predictions for their specific conditions, even if they have limited data available. Compared to existing methods, this approach not only improves prediction accuracy but also enhances the model's ability to adapt to new environments, making it more practical for real-world applications in agriculture.

Novelty
8.0
Reliability
7.5
arxiv/2608.31097 →
PDF preview for An Enclosed Mode Is a Gauge Choice: Topology Relative to Reach in Certified Code World Models
PASS ✓

An Enclosed Mode Is a Gauge Choice: Topology Relative to Reach in Certified Code World Models

2026.08.28reasoning

Javier Aguilar Martín

Imagine you're developing an AI that needs to make decisions based on incomplete information, like a self-driving car navigating through a foggy environment. The challenge lies in how well the AI can understand its surroundings and make safe choices when it can't see everything. Current models often fail in these situations because they can be confident about what they see but completely misjudge what lies beyond their immediate perception — this is known as the 'gauge' problem. When the model's understanding is limited to a certain 'reachable' area, it can lead to dangerous errors in decision-making. This is what's called a topology-related failure, where the model's confidence doesn't match its actual knowledge. The paper proposes a new way to think about these limitations by introducing a concept called the 'gate quotient,' which helps clarify what a model can reliably know and the potential costs of its errors. By analyzing how different model architectures respond to changes in their 'channels' of information, the authors identify three distinct regimes of model behavior: unfalsifiable and harmless, falsifiable and costly, and instantly falsified. This nuanced understanding allows builders to better design models that can mitigate risks associated with their blind spots. Compared to prior work, this approach emphasizes the importance of topology in model performance, providing a clearer framework for addressing the limitations of AI systems in real-world applications.

Novelty
8.5
Reliability
7.0
arxiv/2608.28541 →
PDF preview for Mechanistic Reaction Prediction via Discrete Flow Matching on Graph-Structured Electron Occupation
PASS ✓

Mechanistic Reaction Prediction via Discrete Flow Matching on Graph-Structured Electron Occupation

2026.08.27data

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

Imagine you're trying to design a machine learning model that predicts the outcomes of chemical reactions. Traditionally, approaches either generate product molecules from scratch or modify existing molecular structures based on heuristics. These methods often struggle with accurately capturing the underlying electron dynamics, which are crucial for understanding how reactions actually occur. This limitation can lead to inaccurate predictions, especially in complex scenarios where the reaction pathways are not straightforward. This is what's called a failure in capturing the mechanistic details of reactions. To address this, the authors propose a new method that models chemical reactions as discrete flow matching over electron occupation vectors. By framing the reactant-to-product mapping as a Continuous-time Markov Chain, they can represent the electron rearrangements more accurately. This approach leverages Optimal Transport to create interpretable edit trajectories without needing detailed annotations of elementary steps. Compared to existing models, MAELLE not only performs competitively on standard benchmarks but also shows robustness in out-of-distribution scenarios, maintaining accuracy where others falter. For builders, this means a more reliable tool for predicting chemical reactions that aligns better with established chemical knowledge and can even forecast side products, enhancing the utility of machine learning in chemistry.

Novelty
8.5
Reliability
7.5
arxiv/2608.27429 →
PDF preview for Learning a Continuous Sepsis Severity Score Without Hour-by-Hour Supervision: A Two-Site Retrospective Study
PASS ✓

Learning a Continuous Sepsis Severity Score Without Hour-by-Hour Supervision: A Two-Site Retrospective Study

2026.08.27data

Kevin Zhu, Ryan Zhang, Baraa Abed, et al.

Imagine you're a doctor in a busy ICU, trying to assess the severity of sepsis in your patients. Traditionally, you rely on fixed indices that use outdated variables and weights, which can lead to misjudgments about patient conditions. These indices often fail to reflect the complexities of modern critical care, leading to what’s called calibration drift — where the tools you have don’t match the realities of current patient data. This can result in inappropriate treatment decisions, as the indices are not tailored to the nuances of individual patient trajectories. To address this, the authors developed a new sepsis index that uses 43 routinely collected variables over a 72-hour treatment window, focusing on mortality as a ranking signal rather than a static target. This allows for a more dynamic assessment of patient status, redistributing credit across different time points based on real-time data. Their evaluation showed that this index correlates well with established indices and provides meaningful prognostic information, indicating it could serve as a valuable decision support tool for clinicians. Compared to previous methods, this new index offers a more nuanced and timely understanding of patient outcomes, which could significantly enhance decision-making in critical care settings. For builders in healthcare tech, this means there’s potential to create tools that are not only more accurate but also more aligned with the realities of patient care today.

Novelty
8.0
Reliability
7.5
arxiv/2608.27421 →
PDF preview for Making Clinical Language Models Auditable: Concept-Guided Fine-Tuning for Robust Prediction
PASS ✓

Making Clinical Language Models Auditable: Concept-Guided Fine-Tuning for Robust Prediction

2026.08.27data

Jin Mu, Guanhua Chen

Imagine you're developing a clinical AI that needs to accurately predict patient outcomes based on hospital notes. The challenge is that these notes often contain irrelevant artifacts like templates and boilerplate text that can mislead the model, leading to poor performance when deployed in real-world settings. This issue, known as deployment shift, means that while models may perform well in controlled environments, they struggle to generalize to actual patient data. This is what's called overfitting to artifacts, where the model learns to rely on these misleading cues rather than the true clinical information. To address this, CAST (Concept-guided Artifact Suppression Tuning) offers a framework that uses Sparse Autoencoders to identify and suppress these artifacts during training. By focusing on human-auditable features and employing a pipeline that interprets model decisions, CAST not only improves prediction accuracy but also provides a clear audit trail of the clinical concepts involved. This means that when the model makes a prediction, you can trace back which concepts were influential and which artifacts were intentionally ignored. Compared to traditional fine-tuning methods, CAST not only enhances performance on tasks like mortality prediction but also ensures that the model's decisions are interpretable and reliable in real clinical settings.

Novelty
8.0
Reliability
7.5
arxiv/2608.27397 →
PDF preview for LeVJEPA: Efficient & Scalable Video Pretraining without the Heuristics
PASS ✓

LeVJEPA: Efficient & Scalable Video Pretraining without the Heuristics

2026.08.27visioncode

Lukas Kuhn, Lucas Maes, Giuseppe Serra, et al.

Imagine you're building a system that needs to understand video content, like a smart assistant that can analyze and summarize video clips. The challenge is that current methods for learning from video are often computationally heavy and can lead to representation collapse, where the model fails to learn useful features. This happens because many existing techniques rely on complex architectures or require reconstructing video content in a way that can be inefficient and limiting. For instance, they might use multiple encoders or rely on specific training tricks that complicate the process. This is what's called architectural asymmetry, and it can hinder performance and scalability. LeVJEPA takes a different route by introducing a single encoder trained with a straightforward invariance loss that avoids collapse without needing those complex setups. The key insight is that by focusing on how the encoder views different parts of a video clip, it can learn effectively with much less computational cost. In fact, LeVJEPA can achieve similar or better performance than previous models while using significantly less pretraining compute. This means that for builders, video can become a more practical and efficient medium for training general-purpose visual models, opening up new possibilities for applications that rely on video data.

Novelty
8.5
Reliability
8.0
arxiv/2608.27395 →
PDF preview for Token-Level Advertising
PASS ✓

Token-Level Advertising

2026.08.27agents

Hanbing Liu, Bowei Zhang, Changyuan Yu, et al.

Imagine you're trying to monetize a generative AI platform that provides users with tailored information. Traditional advertising relies on fixed slots where ads are placed, often leading to mismatches between user interests and ad content. This can result in poor user experiences and lower revenue for platforms, a situation known as inefficient ad placement. The challenge is to create a system where advertising feels more integrated and relevant to the user’s experience. This is where the Latent Advertiser Mixture Auction (LAMA) comes in. It allows advertisers to influence the generation of content at a token level, meaning that their preferences can shape the very next piece of information presented to users. By reporting local continuation values, advertisers can create specific next-token policies that the platform uses to generate responses, all while ensuring that the system remains fair and efficient. Compared to traditional methods, LAMA not only enhances the relevance of ads but also improves overall platform welfare and revenue without sacrificing the quality of user interactions. For builders, this means a more seamless integration of advertising into generative AI, potentially leading to better user engagement and monetization strategies.

Novelty
8.0
Reliability
7.5
arxiv/2608.27382 →
PDF preview for Puro-2B: Poor Lab's Qwen2-1.5B Trained on RTX 5090 within $5090
PASS ✓

Puro-2B: Poor Lab's Qwen2-1.5B Trained on RTX 5090 within $5090

2026.08.27scalingcode

Kairong Luo, Jiarui Cui, Yaorui Yin, et al.

Imagine you're a researcher wanting to develop a powerful language model, but the costs of pretraining are astronomical, often exceeding a million dollars. This financial barrier limits access for many in academia and the open-source community. Current solutions, while helpful, still require significant resources, making it hard for smaller teams to compete or innovate. This situation is what's called a scalability issue, where the high costs prevent widespread experimentation and development in the field. To address this, the authors propose a new pretraining recipe that allows for training models at a fraction of the cost, using consumer-grade hardware and efficient training techniques. By leveraging low-precision training and optimizing the data and training process, they manage to train models that perform comparably to more expensive counterparts for under $7K. They also introduce a Puro Cost Scaling Law, which provides insights into how training costs relate to model performance, suggesting that even lower budgets can yield competitive results. This approach not only democratizes access to powerful language models but also encourages more experimentation and innovation in the field, as researchers can now train and fine-tune models without prohibitive costs.

Novelty
8.0
Reliability
8.0
arxiv/2608.27370 →
PDF preview for Agentic Autoresearch for Cell-Edge Power Control: Radically Redefining the Researcher's Role
PASS ✓

Agentic Autoresearch for Cell-Edge Power Control: Radically Redefining the Researcher's Role

2026.08.26agents

Ahmad Khan, Akram Bin Sediq, Sara Azadegi Naeini, et al.

Imagine you're managing resources in a wireless network, trying to optimize performance for users at the edge of the cell. Traditionally, this involves a lot of manual work: you have to carefully design the architecture, choose the right loss function, and set up the training process, all of which can be tedious and error-prone. This is where things can break down — if the architecture isn't well-suited to the problem, or if the loss function doesn't capture the right objectives, the whole system can underperform, leading to poor user experiences and inefficient resource use. This is what's called the design layer challenge in machine learning for wireless resource management. To tackle this, the authors propose a novel approach where an AI agent takes over the entire design process. By using an autoresearch protocol, the agent autonomously edits the training script, runs experiments, and decides which changes to keep based on a single performance metric. This allows it to explore various architectures, input representations, and loss functions without human intervention. In their experiments, the agent achieved remarkable results, closing a significant performance gap while drastically reducing inference costs. This means that for someone building wireless systems, there's now a way to automate the design process, potentially leading to more efficient and effective solutions without the heavy lifting typically required.

Novelty
8.5
Reliability
8.0
arxiv/2608.26093 →
PDF preview for Planetary Prediction Engine: Autonomous Geospatial Prediction via Intelligent Data Selection and Foundation Model Embeddings
PASS ✓

Planetary Prediction Engine: Autonomous Geospatial Prediction via Intelligent Data Selection and Foundation Model Embeddings

2026.08.26datacommunity code

Evelyn Ma, Rama Kumar Pasumarthi, Kishwar Shafin, et al.

Imagine you're tasked with predicting food security in a region, but the data you need is scattered across various platforms, requiring manual collection and complex analysis. This fragmented approach often leads to delays and inaccuracies, making it hard to respond effectively to urgent challenges like disease outbreaks or natural disasters. The current methods can be cumbersome, relying heavily on expert knowledge and manual tuning, which is not scalable or efficient — this is what's called a bottleneck in data-driven decision-making. The Planetary Prediction Engine (PPE) offers a solution by automating the entire process. It allows users to input natural-language queries and then autonomously retrieves and synthesizes relevant data from multiple sources, including Earth observation platforms. PPE not only gathers this data but also optimizes model selection to ensure the best fit for the task at hand, effectively lowering the barrier for high-quality geospatial analytics. Compared to traditional methods, PPE has shown significant improvements in predictive accuracy across various health and environmental indicators, making it a powerful tool for rapid, expert-level deployment in critical scenarios.

Novelty
8.5
Reliability
8.0
arxiv/2608.26088 →
PDF preview for SwarmWorld: Stigmergic technological evolution in societies of language-model agents
PASS ✓

SwarmWorld: Stigmergic technological evolution in societies of language-model agents

2026.08.26agentscommunity code

Subhadeep Pal, Fiona Y. Wang, Markus J. Buehler

Imagine you're trying to create a system where multiple AI agents can work together to build and innovate without needing strict roles or direct communication. In many current setups, agents rely on predefined tasks or centralized control, which can lead to inefficiencies and missed opportunities for collaboration. This is what's called a lack of flexibility, where agents can't adapt to new challenges or leverage each other's strengths effectively. The authors explore a new environment called SwarmWorld, where language-model agents can self-organize and evolve their own technologies by interacting with their surroundings and each other. Instead of being told what to do, these agents explore, gather resources, and construct artifacts based on their observations and experiences. They develop distinct roles over time, such as exploring or maintaining, which allows them to adapt as their environment changes. This decentralized approach leads to the creation of more robust technological solutions compared to traditional isolated search methods, even if the best individual artifact might still come from a strong single agent. The findings suggest that fostering collaboration and allowing agents to learn from their environment can lead to more innovative and resilient outcomes, which is a shift from the typical reliance on direct communication and predefined roles in multi-agent systems.

Novelty
8.5
Reliability
7.5
arxiv/2608.26081 →
PDF preview for What FID Hides: Detecting, Ranking, and Diagnosing Deviations in Generative Evaluation
PASS ✓

What FID Hides: Detecting, Ranking, and Diagnosing Deviations in Generative Evaluation

2026.08.25vision

Hao Chen

Imagine you're developing a generative model for images, and you want to ensure that the outputs are not just statistically similar to real images but also visually recognizable. Currently, many people rely on metrics like Fréchet Inception Distance (FID) and Kernel Inception Distance (KID) to gauge how well their models perform. However, these metrics can be misleading; for instance, they might indicate that a model is performing well even when it produces images that look nothing like the real thing. This is what's called a failure of moment-based metrics, where they can miss crucial distributional differences, leading to a false sense of security about the model's quality. In some cases, models can achieve low FID scores while generating images that are visually unrecognizable, which is a significant concern for builders aiming for high-quality outputs. To address these shortcomings, the paper introduces ZID (Z-resolved Integrated Diagnostic), a new evaluation method that provides a more nuanced view of generative model performance. Instead of relying on a single scalar value, ZID offers three linked outputs: a ranking index for how much a model's output deviates from real data, a permutation p-value to test for distributional equality, and a signed readout to diagnose the nature of dispersion changes. This approach allows builders to better understand the performance of their models, especially in cases where traditional metrics like FID might fail to capture important issues like mode collapse or diversity collapse. By providing a more comprehensive diagnostic tool, ZID helps ensure that the generative models being developed are not only statistically sound but also visually coherent.

Novelty
8.0
Reliability
7.5
arxiv/2608.24881 →
PDF preview for Recursive Experiential-Working Memory Evolution for Long-Horizon Agent Harnesses
PASS ✓

Recursive Experiential-Working Memory Evolution for Long-Horizon Agent Harnesses

2026.08.25agentscode

Zhaochen Yu, Yingcheng Wu, Zhenfei Yin, et al.

Imagine you're building an AI that needs to handle complex, ongoing tasks over extended periods, like managing a project or coordinating multiple actions. The challenge lies in keeping track of what has happened and making decisions based on that history without losing sight of the current context. Traditional approaches often struggle here, leading to issues like forgetting important details, misapplying skills, or failing to adapt when things go wrong — this is what's called context drift or skill misalignment. These failures can severely limit an agent's effectiveness in real-world applications where tasks are not neatly segmented or predictable. To address these challenges, Recuris introduces a recursive memory architecture that allows an agent to maintain a dynamic understanding of its task environment. By using a Working Memory that tracks progress and an Experiential Memory that informs skill selection based on immediate needs, Recuris enables agents to adaptively refine their actions. This method not only helps in identifying where failures occur but also facilitates targeted updates to the agent's skills based on localized evidence. The results are promising: across various long-horizon benchmarks, Recuris significantly boosts task success rates, even achieving state-of-the-art performance in several cases. For builders, this means a more robust framework for developing agents that can learn and improve over time, making them more reliable in complex, real-world scenarios.

Novelty
8.0
Reliability
7.5
arxiv/2608.24876 →
PDF preview for Parameterized Complexity of $L_p$-Lipschitz Constants for Input Convex Neural Networks and $L_p$-Norm Maximization over Zonotopes
PASS ✓

Parameterized Complexity of $L_p$-Lipschitz Constants for Input Convex Neural Networks and $L_p$-Norm Maximization over Zonotopes

2026.08.25infra

Aritra Das, Vincent Froese, Moritz Grillo, et al.

Imagine you're developing a neural network that needs to be robust against small changes in input, like noise or slight variations in data. A key measure of this robustness is the Lipschitz constant, which quantifies how sensitive the network's output is to these perturbations. However, calculating this constant can be quite challenging, especially for more complex architectures. Current methods work well for certain types of networks, but they struggle with others, leading to what's known as computational hardness — a situation where finding a solution is extremely difficult or time-consuming. This is what's called W[1]-hardness, and it means that as the size of the problem grows, the time required to solve it can increase dramatically, making practical applications tough. In this paper, the authors focus on a specific type of neural network called two-layer input-convex neural networks (ICNNs), which have properties that make them easier to analyze. They prove that for a range of norms, specifically the $L_p$ norms, maximizing the Lipschitz constant is computationally hard. By establishing this complexity, they provide a clearer understanding of the limitations and challenges faced when working with these networks. This work not only resolves an open question in the field but also emphasizes the importance of clear mathematical exposition, which can help builders like you navigate the complexities of neural network design more effectively.

Novelty
8.0
Reliability
7.5
arxiv/2608.24865 →
PDF preview for Improving Cross-Problem Vehicle Routing with Locally Augmented Preferences and Representation Disentanglement
PASS ✓

Improving Cross-Problem Vehicle Routing with Locally Augmented Preferences and Representation Disentanglement

2026.08.25agentscode

Arthur Corrêa, Paulo Nascimento, Samuel Moniz

Imagine you're building a logistics system that needs to efficiently route vehicles for various delivery scenarios, like food delivery, package shipping, or ride-sharing. Currently, many systems require separate models for each type of routing problem, which is inefficient and time-consuming. When using reinforcement learning, you often run into issues where the rewards become less informative as the model improves, leading to stagnation. Similarly, preference optimization can get stuck when the generated solutions become too similar, limiting the model's ability to learn from diverse experiences. This is what's called reward-scale disparity and solution stagnation, respectively. To tackle these challenges, the authors propose a new approach that combines a refined training algorithm with a more flexible architecture. The training method, called Preference Optimization with Locally Augmented Refinement (POLAR), enhances the learning process by refining the best solutions before forming comparisons, which helps the model learn more effectively. On the architecture side, the Progressive Layered Extraction (PLE) encoder separates common routing structures from specific constraints, allowing for better generalization across different routing tasks. Together, these innovations lead to a 21.3% improvement over previous benchmarks and better performance on unseen variants, making it easier for builders to create robust multi-task routing systems.

Novelty
8.0
Reliability
7.5
arxiv/2608.24859 →
PDF preview for LION: A Clifford Neural Paradigm for Multimodal-Attributed Graph Learning
PASS ✓

LION: A Clifford Neural Paradigm for Multimodal-Attributed Graph Learning

2026.08.25multimodal

Xunkai Li, Zekai Chen, Zhengyu Wu, et al.

Imagine you're building a system that needs to understand and process information from both text and images, like a smart assistant that can analyze a photo and provide context or answer questions about it. Currently, many approaches to this problem focus on either the text or the image separately, often using rigid methods that don't consider the broader context of the data. This can lead to issues like poor alignment between modalities, where the system fails to effectively integrate information from both sources, which is known as modality misalignment. Additionally, when these systems try to combine the information, they often do so in a simplistic way that doesn't leverage the unique characteristics of each modality, resulting in subpar performance in real-world applications. This is what's called inadequate modality fusion. To tackle these challenges, the authors propose a new approach called LION, which stands for Clifford Neural paradigm. The idea is to create a more flexible and context-aware framework that first aligns the different modalities using a geometric approach grounded in Clifford algebra, allowing for better interaction between text and images. Then, it employs a sophisticated aggregation method that adapts to the specific characteristics of the data, improving how the system combines information from different sources. Compared to previous methods, LION shows significant improvements in performance across various tasks, meaning that for builders, this could lead to more robust and effective multimodal applications that better understand and utilize the data they process.

Novelty
8.0
Reliability
7.5
arxiv/2608.24795 →
PDF preview for Right Diagnoses, Decorative Reasoning:A Perturbation Audit of Medical Chain-of-Thought
PASS ✓

Right Diagnoses, Decorative Reasoning:A Perturbation Audit of Medical Chain-of-Thought

2026.08.25reasoning

Mengzhu Xu, Jifan Gao, Xia Jiang, et al.

Imagine you're a clinician relying on AI to assist in diagnosing patients. You want to trust that the AI's reasoning process is sound, but how do you know if the explanations it provides are genuinely reflective of its decision-making? Current evaluations often treat the reasoning chain as a black box, leading to uncertainty about whether the AI's outputs are reliable or just coincidental. This is problematic, especially in high-stakes medical settings where the cost of errors can be significant. The authors address this issue by developing a medical perturbation audit that rigorously tests how changes to the input affect the AI's reasoning and answers. They use a set of clinically motivated edits to both the questions and the reasoning chains, allowing them to classify the models based on their failure modes. Their findings reveal that a significant portion of the models do not register meaningful changes in their answers when the reasoning chain is altered, indicating a lack of faithfulness in the CoT process. This new framework not only provides a reusable yardstick for evaluating medical LLMs but also highlights the importance of understanding the relationship between reasoning and outcomes in AI applications. For builders, this means there's now a structured way to assess and improve the reliability of AI systems in critical domains like healthcare.

Novelty
8.0
Reliability
7.5
arxiv/2608.24790 →
PDF preview for ReWorld: An Interactive World Model with Long-Horizon Memory
PASS ✓

ReWorld: An Interactive World Model with Long-Horizon Memory

2026.08.24agentscode

Zhifei Chen, Luozhou Wang, Guibao Shen, et al.

Imagine you're building an AI that needs to navigate and interact with a dynamic environment, like a video game or a virtual world. The challenge lies in making sure the AI can remember where it has been and respond to user actions in real time. Current models often struggle with this because they either focus too much on short-term control or try to remember everything, leading to issues like losing track of context or being unable to adapt to new situations — this is what's called the control-memory tension. To address this, ReWorld introduces a method that separates the short-term control from long-term memory during training, allowing the model to handle both effectively at inference. It uses a mix of attention mechanisms, where most heads focus on recent actions while a few can access the entire history, and employs techniques like random head routing and chunk dropping to maintain a sparse but relevant memory. This way, when the model is in action, it can efficiently retrieve important past information without overwhelming its memory capacity. Compared to previous models, ReWorld achieves better control fidelity and generation quality, making it more reliable for real-time applications. This means that for developers building interactive systems, ReWorld offers a more robust framework that can handle complex tasks without losing track of context, ultimately leading to a smoother user experience.

Novelty
8.0
Reliability
7.5
arxiv/2608.23565 →
PDF preview for SWE Refactor Bench: Can Coding Agents Complete a Long-Horizon, Whole-Repository Stack Migration?
PASS ✓

SWE Refactor Bench: Can Coding Agents Complete a Long-Horizon, Whole-Repository Stack Migration?

2026.08.24agentscode

Deyao Hong, Yizhe Chi, Wenyi Li, et al.

Imagine you're maintaining a large software system that has accumulated years of technical debt. When it comes time to migrate to a new architecture or language, the process can be daunting and often requires manual intervention. Current benchmarks for coding agents primarily check if the code behaves correctly after a migration, but they don't verify if the migration itself was actually completed. This leads to a situation where agents might simply copy the old code to pass tests, a problem the authors refer to as Blindness. This oversight can result in significant issues down the line, as the underlying technical debt remains unaddressed. To tackle this, the authors developed SWE Refactor Bench, a benchmark designed to assess coding agents on their ability to perform whole-repository migrations. It includes 20 different migration tasks that cover various types of technical debt. The evaluation process is threefold: first, it checks if the migration was completed, then it tests for behavioral correctness, and finally, it uses independent coding agents to identify any hidden behavioral differences. The results show that only a small percentage of runs successfully pass all stages, highlighting the distinct challenges of migration completeness versus behavioral correctness. This benchmark provides a more comprehensive framework for developing and evaluating coding agents, ensuring they can handle the complexities of real-world software migrations.

Novelty
8.0
Reliability
7.5
arxiv/2608.23564 →
PDF preview for EG-ARSA: An Expert-Grounded Open Model for Visual Road Safety Auditing in Low-Resource Settings
PASS ✓

EG-ARSA: An Expert-Grounded Open Model for Visual Road Safety Auditing in Low-Resource Settings

2026.08.24vision

Md Thamed Bin Zaman Chowdhury, Moazzem Hossain

Imagine you're working on improving road safety in a country where traffic accidents are common, but the data on these incidents is often incomplete and the resources for thorough inspections are scarce. Currently, road safety audits rely heavily on manual inspections and expert evaluations, which can be inconsistent and costly. This is what's called a lack of scalability, making it difficult to proactively address safety issues before they lead to accidents. The proposed solution is to leverage artificial intelligence to create a compact vision-language model that incorporates expert knowledge into a more efficient auditing process. By calibrating a teacher model against authoritative audits, the system ensures that the AI's assessments align closely with human experts before it generates structured supervision for a smaller student model. This approach allows for large-scale data annotation and effective training of the AI model, which is specifically designed for road safety tasks. The introduction of the Bangladesh Road Safety Audit dataset and the Expert-Grounded Road Safety Auditor model marks a significant step forward in making road safety audits more accessible and reliable in low-resource environments. Compared to previous methods, this framework not only improves the accuracy of risk assessments but also demonstrates that a smaller model can outperform larger counterparts, making it a practical solution for real-world applications.

Novelty
8.0
Reliability
7.5
arxiv/2608.23563 →
PDF preview for Provably adaptive sampling with uniform and remasking discrete diffusion models
PASS ✓

Provably adaptive sampling with uniform and remasking discrete diffusion models

2026.08.24scaling

Daniil Dmitriev, Zhihan Huang, Yuting Wei

Imagine you're developing a generative model that needs to produce high-quality outputs quickly, like creating images or text. Traditional methods often rely on sequential updates, which can be slow and inefficient, especially as the complexity of the data increases. This inefficiency is particularly evident when the model's performance is heavily influenced by the dimensionality of the data, leading to what's known as linear scaling issues. When many variables are updated simultaneously, mistakes can compound, making it hard to correct errors during the generation process. This is what's called the 'sampling efficiency problem.' To address this, the authors propose a new approach that allows for parallel updates during the sampling process, using a first-order sampler that can adaptively correct denoising mistakes. By focusing on the intrinsic structure of the target distribution rather than just the ambient dimension, they establish that fewer discretization steps are needed to achieve a desired level of accuracy. Their findings suggest that the complexity of sampling is more about the relationships within the data than the sheer number of dimensions. This shift in understanding could lead to more efficient generative models, making it easier for builders to create applications that require fast and reliable outputs without being bogged down by high dimensionality.

Novelty
8.0
Reliability
7.5
arxiv/2608.23554 →
PDF preview for Prime Agent: A Self-Improving RLM Harness
PASS ✓

Prime Agent: A Self-Improving RLM Harness

2026.08.24agentscode

Seth Karten, Alex L. Zhang, Kevin Thomas, et al.

Imagine you're developing an AI that needs to handle complex tasks over extended periods, like coding or managing workflows. The challenge lies in maintaining context and adapting to new information as tasks evolve. Current systems often struggle with this, leading to issues like losing track of previous interactions or failing to recover from errors — this is what's called context drop and failure recovery issues. These limitations can hinder the effectiveness of AI in real-world applications, where continuous engagement and adaptability are crucial. To address these challenges, Prime Agent offers a structured approach that combines a persistent IPython REPL with a framework for managing histories, memories, and subagent interactions. This allows for a more seamless integration of long-term context and real-time computation, enabling agents to communicate directly and manage their tasks more effectively. By standardizing execution and resource management, Prime Agent not only improves the reliability of agent workflows but also enhances their performance across various tasks, achieving significant improvements in benchmarks like ARC-AGI-3. This means that for builders, Prime Agent provides a more robust foundation for developing AI systems that can operate effectively in dynamic environments, pushing the boundaries of what language models can achieve.

Novelty
8.0
Reliability
7.5
arxiv/2608.23552 →
PDF preview for ConvergeFlow: Language Flow with Provable Convergence to Token Embeddings
PASS ✓

ConvergeFlow: Language Flow with Provable Convergence to Token Embeddings

2026.08.24datacode

Na Li, Yuchen Jiao, Changxiao Cai, et al.

Imagine you're building a language model that needs to generate text in a way that feels natural and coherent. Current models often rely on a method called cross-entropy to guide their predictions, but this can lead to issues where the generated outputs don't always correspond to valid words or phrases. This is problematic because it can result in nonsensical outputs, which is what's called a failure mode in language generation. The challenge is to create a model that can predict valid tokens directly without getting stuck in these pitfalls. To address this, the authors propose a new method called ConvergeFlow, which operates in the embedding space of tokens. Instead of using cross-entropy, it constrains predictions to a specific area defined by valid token embeddings and trains the model using mean squared error. This approach ensures that even if there are errors in the predictions, the model can still converge to valid outputs. They also introduce various sampling techniques to balance the quality of generated text with the model's uncertainty. Compared to previous models, ConvergeFlow shows that it's possible to achieve competitive performance without the traditional reliance on cross-entropy, which could open new avenues for building more robust language models.

Novelty
8.0
Reliability
7.5
arxiv/2608.23551 →
PDF preview for Interpretable AI with Local Distillation
PASS ✓

Interpretable AI with Local Distillation

2026.08.24datacode

Erin Craig, Yiling Huang, Snigdha Panigrahi

Imagine you're working on a healthcare AI that predicts patient outcomes based on complex data like gene expressions. While modern AI models can make accurate predictions, they often act like black boxes, leaving healthcare professionals unsure about how decisions are made. This lack of transparency can be problematic, especially in high-stakes situations where understanding the reasoning behind a prediction is crucial. Current methods often fail to provide insights into the model's decision-making process, which is what's called interpretability failure. This can lead to mistrust in the model's predictions and hinder its adoption in critical applications. To address this, the authors propose a method called local distillation, which combines the strengths of a complex black-box model (the teacher) with a simpler, interpretable linear model (the student). The teacher helps the student by focusing on similar predictions to define what 'local' means, and it provides guidance at each query point. By adding a bit of randomness to the training process, the method assesses which features are consistently important, allowing for a clearer understanding of the model's behavior. This approach not only matches the accuracy of the black-box model but also produces a sparse linear model that reveals different patient subgroups based on their gene expressions, something that a global model might miss. Compared to previous work, local distillation offers a way to maintain high accuracy while significantly improving interpretability, making it a valuable tool for builders in fields where understanding model decisions is essential.

Novelty
8.0
Reliability
7.5
arxiv/2608.23538 →
PDF preview for Primal Acceleration of Newton's Method
PASS ✓

Primal Acceleration of Newton's Method

2026.08.21infra

Nikita Doikov

Imagine you're working on a machine learning model that requires fine-tuning its parameters to minimize a loss function. In many cases, especially with complex models, this involves using optimization methods that can be computationally expensive and slow, particularly when dealing with second-order methods that require calculating the Hessian matrix. Traditional approaches often struggle with efficiency, especially when they rely on solving multiple linear systems or auxiliary problems, which can lead to longer training times and increased resource consumption. This inefficiency is what we call the 'computational bottleneck.' The new method presented here offers a fresh approach to this problem by utilizing a direct accelerated Newton method that only requires one linear solve per iteration. This means it can achieve a global convergence rate of $O(1/k^3)$, which is quite impressive for this class of optimization problems. The method is designed to be Hessian-free, allowing for inexact linear system solvers, which further enhances its efficiency. Additionally, it can be extended to handle more complex scenarios, such as composite optimization problems and arbitrary geometries through Bregman divergence. Compared to prior work, this method stands out by achieving a faster convergence rate without the need for auxiliary nonlinear regularized subproblems or dual extragradient corrections. For someone building optimization algorithms, this means you can expect faster training times and reduced computational costs, making it a valuable tool for developing more efficient machine learning models.

Novelty
8.0
Reliability
7.5
arxiv/2608.21359 →
PDF preview for VIALS: A Benchmark for Visual Interpretation of Artifacts in the Life Sciences
PASS ✓

VIALS: A Benchmark for Visual Interpretation of Artifacts in the Life Sciences

2026.08.21visioncode

Elaine Lau, Thanuka Udumulla, Lee Izhaki-Tavor, et al.

Imagine you're a scientist needing to analyze complex visual data from experiments, like gel blots or microscopy images, to make informed decisions. Currently, while AI can describe everyday images well, it struggles with these specialized scientific visuals, leading to misinterpretations that can affect research outcomes. This gap highlights a significant limitation in AI's understanding of domain-specific knowledge and visual reasoning, which is crucial for scientists who rely on these artifacts for their work. To address this, the authors created VIALS, a benchmark featuring 161 tasks specifically designed for visual question-answering in the life sciences. This benchmark tests how well AI can interpret these scientific images, revealing that current models fall short compared to human experts who find these tasks straightforward. By establishing this benchmark, the work emphasizes the need for AI systems that can accurately interpret scientific visuals, which is essential for their practical application in professional life sciences workflows.

Novelty
8.0
Reliability
7.5
arxiv/2608.21357 →
PDF preview for AI with Authority, from Application to Silicon
PASS ✓

AI with Authority, from Application to Silicon

2026.08.21agentscode

Jason Hickey

Imagine you're a developer trying to ensure that your AI systems work correctly without the usual overhead of extensive human verification. Traditionally, verifying machine-generated outputs is a costly and time-consuming process, often requiring human oversight at every step. This can lead to bottlenecks, especially when scaling up projects, as human reviewers can become a limiting factor. This is what's called the verification bottleneck, where the need for human review slows down progress and increases costs. The paper introduces a new method that flips this dynamic on its head by using generative AI to automate the verification process. Instead of relying on human checks, the Salt method allows AI agents to handle verification autonomously, ensuring that mathematical claims are rigorously checked as they move through the system. This means that a single researcher can direct a fleet of AI agents to produce verified outputs, from application code to silicon, without any human intervention in the proof process. The result is a streamlined workflow that not only saves time but also maintains high reliability, as evidenced by the meticulous tracking of errors and proof provenance. For builders, this means that you can now scale your AI projects more efficiently, relying on a system that ensures correctness without the traditional overhead of human verification.

Novelty
8.5
Reliability
8.0
arxiv/2608.21356 →
PDF preview for PerturbRx: Learning Treatment-Conditioned Latent Transitions for Patient Drug Response Prediction
PASS ✓

PerturbRx: Learning Treatment-Conditioned Latent Transitions for Patient Drug Response Prediction

2026.08.21data

Yoshitaka Inoue, Minoh Jeong, Alfred Hero, et al.

Imagine you're a doctor trying to predict how a specific cancer patient will respond to a new treatment based on their unique molecular profile. Currently, many approaches rely on static data from before treatment, which often fails to capture the dynamic changes that occur once therapy begins. This can lead to inaccurate predictions, as the model doesn't account for how the treatment might alter the patient's biology — a failure mode known as static modeling. Without understanding these changes, treatment plans can be misguided, potentially harming patients or wasting resources. To address this, PerturbRx offers a fresh perspective by learning how treatments induce changes at the molecular level. It does this by training a model on data from both treated and untreated cells, allowing it to predict how a patient's profile will evolve under treatment conditions. This transition model is then applied to patient data before treatment, effectively bridging the gap between pre-treatment profiles and expected post-treatment responses. Compared to existing methods, PerturbRx not only improves predictive accuracy but also provides a more nuanced understanding of patient-drug interactions, which is crucial for personalized medicine.

Novelty
8.0
Reliability
7.5
arxiv/2608.21349 →
PDF preview for Truthful Calibration Measures for Sequential Prediction
PASS ✓

Truthful Calibration Measures for Sequential Prediction

2026.08.21infra

Anagha Gokul, Jason Hartline, Lunjia Hu, et al.

Imagine you're developing a machine learning model that needs to provide reliable probability estimates for its predictions, like whether it thinks an email is spam or not. The challenge is that many existing calibration methods can mislead users, giving them confidence in incorrect predictions. This misalignment between reported probabilities and actual outcomes is known as miscalibration, which can lead to poor decision-making in critical applications. For instance, if a model says there's a 90% chance of rain but it only rains 50% of the time when it makes that claim, users might be caught off guard. This is what's called miscalibration, and it can happen even with independent predictions over time. To address this, the authors propose a new approach to calibration that focuses on achieving approximately truthful measures rather than exact truthfulness, which they argue is incompatible with other desirable properties like completeness and soundness. They introduce two methods to derive new calibration measures that maintain a balance between truthfulness and reliability. Their multiplicative approach, in particular, allows for a calibration measure that is nearly truthful while still being sound and complete. This advancement improves upon previous work by providing a more practical framework for building reliable predictive models, which is crucial for developers aiming to deploy AI systems in real-world scenarios where trust in predictions is essential.

Novelty
8.0
Reliability
7.5
arxiv/2608.21348 →
PDF preview for Anatomy-Informed Neural Networks: Encoding Anatomic Priors in Loss and Architecture, with an SE(3) Formulation of Guidewire-Induced Aortoiliac Deformation
PASS ✓

Anatomy-Informed Neural Networks: Encoding Anatomic Priors in Loss and Architecture, with an SE(3) Formulation of Guidewire-Induced Aortoiliac Deformation

2026.08.21vision

David P. Stonko

Imagine you're a surgeon preparing for a complex aortic surgery, where understanding the anatomy of blood vessels is crucial. Current deep learning models can sometimes produce results that look plausible numerically but don't align with real anatomical structures, leading to potential misguidance during procedures. This is particularly problematic when data is limited, as the models struggle to generalize accurately, which is what's called overfitting. The challenge is to create a model that not only predicts outcomes but also respects the inherent anatomical constraints of the human body. To address this, the authors propose a new approach called Anatomy-Informed Neural Networks (AINN). This method incorporates soft and hard anatomical priors directly into the model's architecture and loss function. For instance, it penalizes unlikely anatomical configurations, like a renal artery branching from the aorta, making such predictions less likely. The model is tested on a clinical scenario involving the deformation of the aortoiliac tree when a stiff wire is introduced, using a sophisticated mathematical framework that connects the predicted outcomes to real-world angiograms. This approach allows for training a 3D model using 2D images, which could significantly enhance predictive accuracy while reducing the amount of training data needed. Compared to previous methods, this model not only aims to improve predictions but also ensures that invalid anatomical configurations are avoided by design.

Novelty
8.0
Reliability
7.5
arxiv/2608.21332 →
PDF preview for Prompt-Model Interaction Reaches the Fixed Points: A deterministic, task-free structural readout -- and the factorizations of it that failed
PASS ✓

Prompt-Model Interaction Reaches the Fixed Points: A deterministic, task-free structural readout -- and the factorizations of it that failed

2026.08.21agents

Nicolás Vera Zúñiga

Imagine you're developing a language model that needs to understand and respond to various prompts effectively. You might think that optimizing a prompt for one model would yield similar results across others, but that's not the case. In practice, prompts that work well for one model can perform poorly on another, leading to unexpected outcomes. This inconsistency highlights a significant gap in our understanding of how prompts influence model behavior, especially when the task isn't clearly defined. The authors explore this by analyzing a specific readout mechanism in models, focusing on how a short sequence of tokens can dramatically shift model performance. They find that while certain conditioning factors can influence outcomes, many proposed explanations fail to hold up under scrutiny. This suggests that the relationship between prompts and models is more complex than previously thought. For builders, this means that relying on prompt optimization alone may not be sufficient; understanding the underlying mechanics of model interactions is crucial for developing robust AI systems.

Novelty
8.0
Reliability
7.0
arxiv/2608.21315 →
PDF preview for Rethinking Expressivity and Efficiency in Test-Time Training
PASS ✓

Rethinking Expressivity and Efficiency in Test-Time Training

2026.08.21scalingcode

Zeyun Zhong, Joya Chen, Manuel Martin, et al.

Imagine you're building a language model that needs to handle long conversations or documents, where keeping track of context is crucial. Current methods for updating model weights during inference often struggle with efficiency, especially when trying to adapt to new information in real-time. They either update weights for each token, which can be computationally expensive, or use chunk-wise approximations that lose important temporal details, leading to what's called a loss of expressivity. This can result in models that don't perform well when faced with longer contexts or new data that wasn't part of their training. E$^2$-TTT offers a solution by allowing for continuous weight updates during inference while maintaining efficiency. It does this by deriving a closed-form state transition that captures the necessary dynamics of per-token updates but applies them in a way that can be processed in parallel across chunks. This means you can train large models efficiently while still preserving the ability to adapt to new information effectively. In tests, E$^2$-TTT not only matches the performance of previous methods but also excels in scenarios requiring long-context understanding, making it a significant step forward for anyone looking to build robust language models.

Novelty
8.0
Reliability
7.5
arxiv/2608.21308 →
PDF preview for ConceptGuard: Benchmarking Context-Sensitive Unlearning in Large Language Models
PASS ✓

ConceptGuard: Benchmarking Context-Sensitive Unlearning in Large Language Models

2026.08.20alignmentcode

Sahil Kale, Ian Harris

Imagine you're developing a large language model that needs to safely handle sensitive information, like personal data or harmful content. The challenge is not just to forget specific facts but to ensure that the model can still use related, benign knowledge without causing harm. Current methods often test unlearning by simply checking if certain facts are forgotten, but this approach misses the bigger picture — it doesn't account for the nuanced ways concepts can be used in both harmful and helpful contexts. This is what's called a failure to capture the complexity of unlearning, leading to models that might still exhibit unsafe behaviors despite removing specific facts. To address this, the authors propose a new framework that focuses on 'dual-use concepts' — ideas that can be applied in both harmful and benign ways. They introduce a benchmark called ConceptGuard, which evaluates unlearning at the conceptual level rather than just through isolated facts. This allows for a more meaningful assessment of how well a model can forget harmful applications while retaining useful knowledge. The findings reveal that existing unlearning techniques struggle with this more complex evaluation, showing poor performance in maintaining contextual sensitivity and control over concepts. For builders, this means that if you're working on LLMs, you need to rethink how you evaluate unlearning capabilities to ensure safety in real-world applications.

Novelty
8.5
Reliability
7.0
arxiv/2608.20338 →
PDF preview for QUASAR: A Quantum-Classical Neural Network for SAR Satellite Physical-Layer Authentication
PASS ✓

QUASAR: A Quantum-Classical Neural Network for SAR Satellite Physical-Layer Authentication

2026.08.20infra

Vincenzo Sammartino, Nathanael Denis, Roberto Di Pietro

Imagine you're working on securing satellite communications, which are crucial for disaster response and military operations. Currently, most systems rely on radio-frequency fingerprinting, but these methods struggle with the unique challenges posed by X-band SAR satellites, particularly at higher frequencies. They often underperform because they can't effectively capture the complex nonlinearities in the signals, leading to vulnerabilities in authentication. This is what's called physical-layer authentication (PLA), and existing solutions typically fall short in this domain. To address these issues, QUASAR combines a convolutional neural network (CNN) with a variational quantum circuit (VQC). This hybrid approach not only enhances data efficiency—requiring only 10% of the training data to achieve comparable accuracy to classical methods—but also improves classification performance under various adversarial conditions. In tests against replay attacks, crafted-IQ injections, and space-borne spoofing, QUASAR successfully rejected a significant percentage of spoofed transmissions, marking a notable step forward in the field. Compared to prior work, QUASAR's unique architecture and its ability to operate effectively with less data represent a meaningful shift in how we can secure satellite communications. For builders in this space, this means a more robust and efficient way to authenticate signals, potentially reducing the time and resources needed for data collection and improving overall security.

Novelty
8.5
Reliability
7.5
arxiv/2608.20240 →
PDF preview for Rule-Compliant Visual Spatial Planning for Multimodal Large Language Models
PASS ✓

Rule-Compliant Visual Spatial Planning for Multimodal Large Language Models

2026.08.20multimodalcode

Yu Chen, Ting Lei, Yaoyi Li, et al.

Imagine you're developing a multimodal AI that needs to navigate complex environments while following specific rules, like a robot in a maze. Current models often struggle with this task because they lack the ability to effectively combine visual understanding with natural language processing, especially when faced with new or complex rules. This leads to failures in accurately interpreting instructions or planning actions, which is a problem known as rule compliance failure. Without a structured way to evaluate and improve these capabilities, it's hard to know how well these models will perform in real-world scenarios. To address this, the authors created RuleMaze, a benchmark that challenges models to navigate mazes while adhering to natural language rules of varying complexity. They also introduced a method called Disentangled Multimodal Planning (DMP), which breaks down the tasks of perception, execution, and rule verification into separate components. This separation allows for better generalization to new rules and provides clearer insights into the planning process. Compared to previous approaches, RuleMaze and DMP offer a more systematic way to evaluate and enhance the spatial planning abilities of multimodal models, making it easier for builders to develop reliable AI systems that can operate in dynamic environments.

Novelty
8.5
Reliability
7.5
arxiv/2608.20237 →
PDF preview for Growth Without Us: Machine Consumers, Corporate Circularity, and the Decoupling of GDP from Humanity after AGI
PASS ✓

Growth Without Us: Machine Consumers, Corporate Circularity, and the Decoupling of GDP from Humanity after AGI

2026.08.20agents

Sahil Sharma

Imagine you're trying to design a future economy where artificial intelligence and robots handle most of the work. Today, we often think about how humans will fit into this picture, especially regarding jobs and consumption. The common concern is that if machines do all the work, who will buy the products? This perspective limits our understanding of how a fully automated economy could function. The paper argues that in a post-AGI world, corporations could own AI and robotic agents that not only produce goods but also consume resources, creating a self-sustaining economic cycle. This is what's called demand closure, where the economy can grow without human consumption, similar to a von Neumann expanding economy. The authors also highlight that as machines replace humans in production, the constraints on growth shift from human demographics to the efficiency of machine fabrication and energy use, potentially allowing for exponential growth rates. Furthermore, they discuss how human welfare becomes decoupled from economic output, suggesting that ownership of the corporate network becomes the key factor in determining human well-being. This shifts the focus from employment policies to ownership policies, indicating that in a future dominated by AI, how we manage ownership will be crucial for societal welfare.

Novelty
8.5
Reliability
7.0
arxiv/2608.20231 →
PDF preview for SPADE: Self-Play in Adaptive Synthetic Executable Environments
PASS ✓

SPADE: Self-Play in Adaptive Synthetic Executable Environments

2026.08.19agentscode

Bo Liu, Simon Yu, Yiding Jiang, et al.

Imagine you're building a language model that needs to continuously improve its reasoning and tool-use skills over time. The challenge is that traditional training methods often rely on fixed environments, which can limit the model's ability to adapt and grow as it encounters new tasks. This leads to issues like stagnation in learning and an inability to handle unexpected scenarios, which is what's called a lack of adaptability in training environments.  To address this, SPADE introduces a self-play framework where a single language model takes on two roles: one as an Environment Designer that creates diverse training scenarios and another as a Reasoning Agent that learns to navigate these scenarios. This setup allows the model to generate and refine its own training environments dynamically, targeting challenges that push its capabilities while remaining feasible. By grounding the Environment Designer in a large pretraining corpus and utilizing an accumulated memory of environments, SPADE significantly outperforms existing fixed-environment baselines across various benchmarks, indicating a step toward more open-ended self-improvement in AI systems.

Novelty
8.5
Reliability
7.5
arxiv/2608.19197 →
PDF preview for Lévy Attention: Single-Pass Predictive Uncertainty for Continuous-Time Attention
PASS ✓

Lévy Attention: Single-Pass Predictive Uncertainty for Continuous-Time Attention

2026.08.19data

Sotirios P. Chatzis, Loukas Papadoulas

Imagine you're developing a system that analyzes time series data, like monitoring patient vitals or stock prices, where the data points come in at irregular intervals. The challenge is not just making accurate predictions at any given time, but also understanding how much to trust those predictions. Current models often provide answers without any indication of their reliability, which can lead to poor decision-making when the stakes are high. This lack of trustworthiness is particularly problematic in sparse data scenarios, where the model's confidence can be misleading. This is what's called uncertainty quantification, and it’s a critical aspect that many existing models overlook. To address this, the authors propose a new approach called Lévy Attention, which integrates a stochastic formulation into the attention mechanism. This method not only generates predictions but also quantifies their reliability by calculating a measure of uncertainty based on the data's characteristics. By using a Poisson random measure, the model captures the variability in the data and provides a calibrated estimate of trustworthiness alongside each prediction. This dual output allows for better decision-making, especially in scenarios where data is sparse or irregular. Compared to traditional softmax-based attention, Lévy Attention retains valuable information about the data's distribution, leading to more reliable predictions. For builders, this means you can deploy models that not only predict outcomes but also give you a clear sense of how much to trust those predictions, which is crucial in high-stakes applications like healthcare or finance.

Novelty
8.5
Reliability
7.5
arxiv/2608.19171 →
PDF preview for AutoSR: Automatic Symbolic Regression by Searching Research States
PASS ✓

AutoSR: Automatic Symbolic Regression by Searching Research States

2026.08.17data

Kejia Zhang, Youran Sun, Xinyu Ren, et al.

Imagine you're a scientist trying to derive equations that explain complex phenomena from experimental data. Traditionally, you might use symbolic regression to find a mathematical expression that fits your data, but this often leads to equations that work well only within the specific range of your data. This is problematic because the resulting equations can behave unpredictably outside that range, and the process usually discards valuable insights about why certain equations were considered in the first place. This is what's called a lack of scientific credibility in the results. Existing methods focus on refining equations but often overlook the broader context of the research, including motivations and the reasoning behind each candidate equation. The approach introduced in this paper, Automatic Symbolic Regression (AutoSR), addresses these issues by coupling each candidate equation with a comprehensive record of the research process, including the reasoning and evidence that led to its development. By using a method called progressive-widening Monte Carlo tree search (PW-MCTS), AutoSR explores multiple scientific investigations simultaneously, ensuring that the accumulated knowledge informs future searches. This means that instead of just getting a final equation, you also receive a detailed report explaining how that equation was derived and why it was chosen. Compared to previous work, AutoSR not only finds mathematically valid expressions but also preserves the scientific narrative that guides the exploration, making it a more robust tool for scientific inquiry.

Novelty
8.5
Reliability
7.5
arxiv/2608.16876 →
PDF preview for Non-Crossing Deep Quantile Regression for Distributional Survival Prediction
PASS ✓

Non-Crossing Deep Quantile Regression for Distributional Survival Prediction

2026.08.17datacode

Shuai Huang, Zhe Qu, Zhaowei Hua, et al.

Imagine you're a healthcare analyst trying to predict patient survival times based on various factors like age, treatment, and health history. Traditional methods often boil this complex information down to a single hazard ratio, which can obscure important variations in how different factors influence survival at different times. This can lead to misleading conclusions, especially when the survival distribution is not uniform — a situation known as the limitations of hazard-based summaries. What you really need is a way to capture the full picture of survival probabilities over time, reflecting how these probabilities change as conditions evolve. The authors propose a new framework called Censored Non-crossing Quantile (CNQ) that addresses these issues by estimating multiple conditional survival quantiles while ensuring that the results are logically consistent and ordered. By leveraging advanced techniques like Kolmogorov-Arnold and Transformer architectures, this approach allows for greater flexibility in modeling survival data. In tests across various scenarios and real-world clinical studies, CNQ outperformed existing methods, particularly when the underlying survival distributions were asymmetric. This means that for someone building predictive models in healthcare, using CNQ could lead to more accurate and nuanced insights into patient survival, ultimately improving decision-making and patient outcomes.

Novelty
8.0
Reliability
7.5
arxiv/2608.16864 →
PDF preview for Model Hypnosis: Strong control of AI via additive subliminal effects
PASS ✓

Model Hypnosis: Strong control of AI via additive subliminal effects

2026.08.17alignmentcode

Enric Boix-Adsera, Benedict Tessler

Imagine you're developing an AI that needs to respond accurately to user prompts, but you notice that even minor changes in the input can lead to unexpected and often undesirable outputs. This inconsistency arises because AI models can be overly sensitive to seemingly trivial details in the prompts, such as typos or slight rephrasings. This phenomenon, termed model hypnosis, highlights a significant challenge in ensuring reliable AI behavior, as it shows that weak cues can be combined in ways that strongly influence the model's responses. This is what's called model hypnosis, where the model's behavior is controlled by inconspicuous textual choices, leading to potential safety and interpretability issues. The authors propose that understanding and addressing model hypnosis is crucial for improving AI safety and interpretability. By recognizing how these hypnotic prompts can transfer across different models, builders can better anticipate and mitigate risks associated with AI deployment. This work shifts the focus from merely fine-tuning models to understanding the underlying mechanisms that govern their behavior, which is essential for creating more robust and trustworthy AI systems.

Novelty
8.5
Reliability
7.0
arxiv/2608.16834 →
PDF preview for Rollplex: Cross-Phase GPU Spatial Sharing for Vision Language Model Post-Training
PASS ✓

Rollplex: Cross-Phase GPU Spatial Sharing for Vision Language Model Post-Training

2026.08.14agents

Hanfeng Lu, Tianyu Feng, Suyi Li, et al.

Imagine you're building a smart assistant that can understand both images and spoken commands, like a robot that can follow your instructions based on what it sees. Currently, when using reinforcement learning (RL) to train these models, the process is quite rigid. It runs in strict phases: first, it gathers data from the environment, then it evaluates that data, and finally, it updates the model. This serial approach can waste a lot of computing power, especially when processing complex visual inputs, because some tasks can be done simultaneously but aren't due to the current setup. This inefficiency is what's called phase-granular execution, and it leads to underutilized resources, particularly in GPU-heavy environments. To address this, the authors propose a new runtime called Rollplex, which allows for overlapping the computation of visual prompts with the rollout phase of RL. By managing memory and sharing weights more intelligently, Rollplex enables these tasks to run concurrently without disrupting the synchronous nature of RL updates. This results in a notable speedup in processing time, achieving up to 2.24 times faster performance compared to traditional methods. For builders, this means you can train more capable vision-language models more efficiently, making better use of your hardware and potentially speeding up development cycles.

Novelty
8.0
Reliability
7.5
arxiv/2608.14498 →
PDF preview for OmniScientist: An Omni-Modal Omni-Discipline AI Scientist
PASS ✓

OmniScientist: An Omni-Modal Omni-Discipline AI Scientist

2026.08.13agentscode

Bobo Li, Hao Fei, Tianjie Ju, et al.

Imagine you're a researcher trying to make sense of a mountain of diverse data — images, audio, tables, and more — to generate new scientific insights. Currently, most systems focus on analyzing text or precomputed summaries, which often leads to missing critical relationships and insights that could be gleaned from the raw data itself. This limitation can result in incomplete or biased conclusions, a problem known as data silos, where valuable information is left untapped. The OmniScientist addresses this by integrating a perception layer that allows it to process and reason over various types of raw evidence directly, rather than relying solely on preprocessed inputs. It employs three autonomous agents that handle ideation, experimentation, and manuscript writing, creating a seamless workflow that adapts based on real-time observations and findings. This holistic approach not only enhances the research process but also ensures that the results are grounded in comprehensive evidence. Compared to existing systems, OmniScientist's ability to operate across multiple modalities and maintain a continuous feedback loop throughout the research lifecycle marks a significant advancement, making it a valuable tool for anyone looking to push the boundaries of scientific discovery.

Novelty
8.5
Reliability
7.5
arxiv/2608.13558 →
PDF preview for Defensive Boosting for Online Probabilistic Forecasting
PASS ✓

Defensive Boosting for Online Probabilistic Forecasting

2026.08.13reasoningcommunity code

Georgy Noarov, Aaron Roth

Imagine you're building a system that needs to predict binary outcomes, like whether a user will click on an ad or not, but the conditions can change unpredictably. Current methods often fall short because they either excel in scenarios where a good predictor exists or they can drive errors to zero under specific conditions, but not both. This limitation can lead to poor performance when the underlying assumptions about the data are violated, which is a common issue in real-world applications. This is what's called the 'weak-learning condition' failure, where the algorithm struggles to adapt effectively. To address this, the authors propose a new algorithm called the Defensive Booster. It cleverly combines the strengths of existing online boosting techniques, ensuring that it remains competitive in terms of Brier score while also maintaining low classification error when the conditions are right. The key insight is that when the algorithm's performance dips, it can identify this and adjust its approach, effectively providing a safety net. This method is efficient, requiring only one weak learner instead of a large ensemble, which simplifies deployment and reduces computational costs. Compared to previous methods, the Defensive Booster not only improves predictive performance but also does so with significantly faster runtimes, making it a practical choice for developers working with dynamic data streams.

Novelty
8.0
Reliability
7.5
arxiv/2608.13554 →
PDF preview for QuoteBench: How Matched Scores Can Hide Command-Path Failures
PASS ✓

QuoteBench: How Matched Scores Can Hide Command-Path Failures

2026.08.13agentscode

Shangao Li, Yao Zhang, Volker Tresp, et al.

Imagine you're building a coding assistant that generates Bash commands to automate tasks. The challenge isn't just getting the right command; it's ensuring that the command works correctly in the specific environment where it's executed. Current evaluations often focus on whether the generated command is correct in isolation, missing critical issues that arise when commands are processed through various interfaces or parsers. This can lead to errors that aren't apparent until execution, which is what's called execution transport failure. For instance, a command might look perfect on paper but fail due to how it's interpreted by the system after generation. This is a significant gap in how we assess the capabilities of these AI agents. To address this, the authors propose QuoteBench, a new evaluation framework that rigorously tests command-issuing agents across multiple configurations and tasks. By validating the final state after execution, they can pinpoint where failures occur and how much recovery is possible through model adjustments. This approach reveals that many models perform well in isolation but struggle significantly when faced with real-world execution challenges. For builders, this means that simply relying on matched scores isn't enough; understanding the entire context of command generation and execution is crucial for developing reliable AI agents.

Novelty
8.0
Reliability
7.5
arxiv/2608.13547 →
PDF preview for LittleLearner: Language Models Under Pedagogically Controlled Knowledge Exposure
PASS ✓

LittleLearner: Language Models Under Pedagogically Controlled Knowledge Exposure

2026.08.13data

Fanfei Li, Jana Zeller, Manuel Prada-Corral, et al.

Imagine you're developing a language model that needs to understand and generate content suitable for elementary school students. The challenge lies in ensuring that the model's knowledge is appropriately limited to what a fifth grader would know, which is difficult when training on vast, mixed datasets from the internet. This often leads to models that can produce advanced responses or exhibit knowledge beyond their intended scope, which can be problematic in educational contexts — this is what's called overfitting to the training data. To tackle this, the authors created LITTLECURRICULUM, a carefully curated dataset specifically designed for U.S. elementary school material, ensuring that the model only learns concepts appropriate for that age group. By training a 5B-parameter model, LITTLELEARNER, on this dataset, they establish clear boundaries for what the model can and cannot do, making it easier to study how it acquires and uses knowledge. The controlled environment allows for targeted experiments, such as testing how well the model can learn new information after its initial training without expanding its knowledge base beyond the defined curriculum. This approach contrasts with traditional methods that often lead to models with unpredictable capabilities, providing a more reliable framework for educational applications.

Novelty
8.0
Reliability
7.5
arxiv/2608.13545 →
PDF preview for SAEVerbalizer: Generating Explanations for Sparse Autoencoder Features via Representation Verbalization
PASS ✓

SAEVerbalizer: Generating Explanations for Sparse Autoencoder Features via Representation Verbalization

2026.08.13reasoning

Weihan Meng, Hongzhu Guo, Yi Jing, et al.

Imagine you're building a system that needs to interpret complex data from large language models, like understanding the features they extract. Currently, the process of explaining these features often relies on external observations, which can lead to shallow insights and inefficiencies when trying to gather evidence at scale. This reliance can result in what's called superficial explanations, where the true meaning behind the model's behavior remains unclear. As a builder, you want a more direct way to understand and communicate these features without getting bogged down in cumbersome observation methods. The authors propose a solution with SAEVerbalizer, which integrates decoder directions from sparse autoencoders directly into the representations of a language model. This framework fine-tunes the model's downstream layers to produce natural-language explanations of the features, allowing for a more intuitive understanding of what the model is doing. The results show that this verbalization capability not only generalizes to unseen features but also adapts across different sparse autoencoder dictionaries and models. This means that as a builder, you can leverage this method to create systems that explain their reasoning more transparently and effectively, ultimately leading to better user trust and understanding.

Novelty
8.0
Reliability
7.5
arxiv/2608.13538 →
PDF preview for DARTree: Speculative Diffusion Decoding with Autoregressive Draft Trees
PASS ✓

DARTree: Speculative Diffusion Decoding with Autoregressive Draft Trees

2026.08.13agentscode

Tianyi Li, Yaxin Luo, Xinyi Shang, et al.

Imagine you're building a language model that needs to generate text quickly and accurately, like drafting responses in a chat application. Current methods often rely on generating tokens one at a time, which can be slow and inefficient, especially when trying to verify multiple options simultaneously. This sequential approach can lead to bottlenecks, where the model struggles to keep up with user expectations, resulting in delays or less coherent outputs. This is what's called autoregressive decoding, and while it works, it can be limiting in terms of speed and flexibility. To address these issues, DARTree proposes a new way to handle speculative decoding by organizing token proposals into a tree structure rather than a single chain. This allows the model to evaluate multiple potential token sequences in parallel, significantly speeding up the process. By constructing a fixed-width candidate tree and applying best-first pruning, DARTree can efficiently select the most promising paths for verification without the overhead of traditional sequential methods. Compared to previous approaches, DARTree achieves a notable increase in both the number of tokens accepted per round and overall decoding speed, making it a compelling option for developers looking to enhance the performance of autoregressive models in real-world applications.

Novelty
8.0
Reliability
7.5
arxiv/2608.13524 →
PDF preview for Vero: Can AI Agents Build Formally Verified Software Repositories?
PASS ✓

Vero: Can AI Agents Build Formally Verified Software Repositories?

2026.08.13agentscode

Zhe Ye, Hantao Lou, Yuechun Sun, et al.

Imagine you're developing an AI that can write complex software, but you need to ensure that the code it generates is correct and meets specific requirements. Currently, many AI systems can produce code, but they often lack a way to verify that the code works as intended, leading to potential errors and vulnerabilities. This is particularly problematic in multi-module systems where the interactions between different parts of the code can introduce unforeseen issues, a situation known as integration failure. Existing benchmarks typically focus on isolated functions or only on generating proofs without considering the actual implementation, which doesn't reflect the real-world challenges developers face. To address this gap, the authors created Vero, a benchmark designed to evaluate both the implementation of code and the generation of formal proofs at the repository level. Vero includes 43 multi-module instances from actual codebases, covering various programming languages and domains. It allows for a comprehensive assessment of AI agents by providing curated specifications and reference implementations, along with an audit mechanism that helps identify and correct errors in both code and specifications. This means that Vero not only tests how well an AI can generate code but also how effectively it can ensure that the code meets its intended specifications, providing a more realistic measure of progress in verified software synthesis compared to previous benchmarks.

Novelty
8.0
Reliability
7.5
arxiv/2608.13522 →
PDF preview for Exponential quantum advantage for learning signals with a single qubit
PASS ✓

Exponential quantum advantage for learning signals with a single qubit

2026.08.13infra

Ishaan Kannan, Sridhar Prabhu, Saeed A. Khan, et al.

Imagine you're working on a project that involves detecting weak signals, like those from dark matter or wireless communications. Traditional methods often require a massive number of measurements to extract useful information, which can be time-consuming and resource-intensive. This is particularly problematic when dealing with complex signals that change over time, leading to inefficiencies and potential inaccuracies in the data collected. This challenge is known as the measurement bottleneck, where the sheer volume of data needed can overwhelm existing experimental setups. To address this, researchers have developed a method that leverages a single controllable qubit coupled with a conventional sensor. This approach allows for a dramatic reduction in the number of measurements needed to learn about classical signals, achieving up to a ten million-fold decrease in some cases. The key innovation here is a framework called Quantum Phase-Space Inference (QΨ), which not only provides a way to optimize learning algorithms but also certifies the quantum advantage gained. This means that for builders working on applications in sensing or communication, the ability to learn from fewer measurements can lead to faster, more efficient systems that are better suited for real-world challenges.

Novelty
8.5
Reliability
8.0
arxiv/2608.13521 →
PDF preview for The data geometry of masking diffusion: Certified-optimal schedules via unmasking growth complexity
PASS ✓

The data geometry of masking diffusion: Certified-optimal schedules via unmasking growth complexity

2026.08.13data

Martin J. Wainwright

Imagine you're developing a machine learning model that needs to sample from complex data distributions, like images or text. The challenge lies in ensuring that the sampling process is both efficient and accurate, especially as the dimensionality of the data increases. Current methods often struggle with discretization errors, which can lead to suboptimal performance — this is what's called KL discretization error. When sampling from high-dimensional spaces, these errors can accumulate, resulting in poor model outputs or increased computational costs. This is particularly problematic in applications where precision is critical, such as in generative models or reinforcement learning tasks. To address these issues, the authors propose a new concept called unmasking growth complexity (UGC), which provides a way to measure and optimize the sampling process based on the underlying geometry of the data. By analyzing how data can be revealed in a structured manner, they develop methods that adapt the sampling strategy to the specific characteristics of the data. This leads to what they term certified-optimal samplers, which can achieve a desired level of accuracy with significantly reduced computational effort compared to traditional methods. The results show that by leveraging the UGC, one can achieve substantial improvements in sampling efficiency, particularly in high-dimensional settings, making it a valuable tool for anyone working on complex machine learning tasks.

Novelty
8.0
Reliability
7.5
arxiv/2608.13520 →
PDF preview for Intervention-Aware Clinical World Model for Post-Op Outcome Forecasting in Cardiology
PASS ✓

Intervention-Aware Clinical World Model for Post-Op Outcome Forecasting in Cardiology

2026.08.13data

Yunsung Chung, Yingshuo Liu, Abboud F. Hassan, et al.

Imagine you're a healthcare provider trying to predict how a patient will recover after a procedure like atrial fibrillation ablation. Traditionally, models simplify this process by treating recovery as a straightforward path from initial measurements to a final outcome. However, recovery is often messy and irregular, with various factors like medication changes and follow-up observations that can significantly alter a patient's risk profile over time. This disconnect can lead to inaccurate predictions, which is what's called a failure mode in clinical modeling. To address this, the authors propose a new approach that treats each patient's recovery as a dynamic process. They create a structured latent state that evolves based on time-ordered events and clinical observations, allowing for a more nuanced understanding of recovery. By encoding baseline imaging into a 3D spatial state and updating it with real-time data, the model captures the complexities of patient recovery. It uses follow-up imaging to train the model, focusing on predicting recurrence risk and other outcomes without needing additional MRI scans during inference. Compared to traditional methods, this model offers a more accurate and flexible way to assess patient recovery, which could lead to better clinical decision-making. The ability to query recurrence risk at different time horizons and adjust for missing data during recovery periods represents a significant advancement in how we can model and understand patient outcomes in clinical settings.

Novelty
8.0
Reliability
7.5
arxiv/2608.13518 →
PDF preview for Bagging Robustly Learns VC Classes with Linear Sample Complexity
PASS ✓

Bagging Robustly Learns VC Classes with Linear Sample Complexity

2026.08.13infra

Omar Montasser

Imagine you're developing a machine learning model that needs to perform reliably even when faced with adversarial examples — inputs designed to trick the model into making mistakes. Currently, many approaches struggle with this, often requiring extensive training data or complex architectures that can still fail under adversarial conditions. This is what's called vulnerability to adversarial attacks, which can lead to significant performance drops in real-world applications. The existing methods often have high sample complexity, making them impractical for many scenarios. In response, this paper introduces a new approach that combines a classic technique called bagging with robust empirical risk minimization. The key insight is that by using multiple independent samples and aggregating their predictions, the model can achieve adversarial robustness with a sample complexity that scales linearly with the VC dimension. This is a notable improvement over previous methods, which had much higher sample complexity. The authors also establish a lower bound, showing that their approach is not just effective but necessary, as any learner in this context requires a certain number of calls to an oracle for robust learning. For builders, this means you can develop more reliable models that are easier to train and deploy in adversarial environments.

Novelty
8.0
Reliability
8.0
arxiv/2608.13514 →
PDF preview for Equivariant learning of a transferable three-dimensional classical density functional
PASS ✓

Equivariant learning of a transferable three-dimensional classical density functional

2026.08.13data

Bingqing Cheng

Imagine you're trying to predict how liquids behave under different conditions, like temperature changes or when confined in small spaces. Currently, this often requires running separate simulations for each scenario, which can be time-consuming and inefficient. This is problematic because it limits our ability to quickly understand and manipulate liquid behavior in practical applications, such as in materials science or chemical engineering. This challenge is known as the need for separate atomistic simulations for each state, which can be cumbersome and resource-intensive. To address this, the authors propose a method that learns a free-energy functional directly from three-dimensional equilibrium density fields. This approach allows for a single learned functional to be applicable across various temperatures and system sizes, effectively capturing the essential thermodynamic properties without needing specific training targets. By applying this method to complex geometries, they can predict behaviors like the forces involved in the formation of solvent-depleted bridges between colloids. This advancement means that builders can now leverage a more efficient way to connect microscopic liquid structures to their macroscopic behaviors, streamlining the process of understanding and designing liquid systems.

Novelty
8.5
Reliability
7.5
arxiv/2608.13506 →
PDF preview for Surgical WAM: A World-Action Model for Data-Efficient Surgical Robot Learning
PASS ✓

Surgical WAM: A World-Action Model for Data-Efficient Surgical Robot Learning

2026.08.11vision

Wenrui Bao, Tianyun Jiang, Zhiben Chen, et al.

Imagine you're developing a surgical robot that needs to perform complex tasks like suturing or transferring objects. The challenge is that collecting the precise action-labeled data for training is both expensive and time-consuming, making it hard to teach the robot how to handle delicate procedures. Current methods often rely on synchronized video and kinematics, but these are not only costly but also limited in their ability to capture the nuances of surgical dynamics. This is what's called the data scarcity problem, where the lack of labeled demonstrations hampers the learning process for surgical manipulation policies. To address this, the authors propose a method that leverages the abundance of action-free endoscopic video to learn the visual dynamics of surgical scenes. By introducing the Surgical World-Action Model (Surgical WAM), they create a generative model that predicts both future video frames and the corresponding actions the robot should take. This model is first trained on the video data and then fine-tuned with a limited set of labeled actions. The result is a closed-loop controller that can adapt its actions based on real-time observations, significantly improving success rates in simulated surgical tasks. Compared to previous approaches, this method shows that using video pretraining can effectively bridge the gap created by limited action supervision, making it a practical solution for scaling up surgical robot learning.

Novelty
8.0
Reliability
7.5
arxiv/2608.11204 →
PDF preview for ConVAWG: A Retrieval-Grounded Framework for Controlled Synthetic Dialogue Generation in Violence Against Women and Girls
PASS ✓

ConVAWG: A Retrieval-Grounded Framework for Controlled Synthetic Dialogue Generation in Violence Against Women and Girls

2026.08.11data

Chen Lyu, Xingwei Tan, Simon Cullen, et al.

Imagine you're trying to understand the dynamics of conversations around sensitive topics like violence against women and girls. Gathering real data in these areas is incredibly challenging due to privacy concerns and the potential for harm, which means researchers often rely on limited datasets that don't capture the complexity of these interactions. Current methods typically focus on isolated instances of abusive language rather than the ongoing relational dynamics that unfold over multiple exchanges, which is a significant gap in understanding how such abuse manifests in conversation. This is what's called a failure to model the temporal and relational aspects of dialogue. To address this, the authors developed a framework called ConVAWG, which generates synthetic dialogues that reflect real-world scenarios of violence against women and girls. By using persona seeds and demographic data, they create rich, multi-turn dialogues that simulate the complexities of these interactions. The framework not only generates dialogues but also incorporates mechanisms to control for toxicity in the generated content, ensuring that the dialogues are both realistic and ethically sound. Compared to previous work, ConVAWG offers a more nuanced approach to studying conversational abuse by providing a large dataset of over 6,000 dialogue events across various scenarios. This means that for those building tools or conducting research in this area, there is now a more robust resource to explore the dynamics of abusive conversations, ultimately leading to better understanding and potential interventions.

Novelty
8.0
Reliability
7.5
arxiv/2608.11200 →
PDF preview for Long-Horizon AI Research for Grothendieck Constant: A Case Study in Human-AI Mathematical Collaboration
PASS ✓

Long-Horizon AI Research for Grothendieck Constant: A Case Study in Human-AI Mathematical Collaboration

2026.08.11agents

Alan Li, Rahul Saha, Anton Xue, et al.

Imagine you're a mathematician trying to solve complex problems that involve both discrete and continuous elements, like optimizing bounds in combinatorial settings. Traditionally, this work relies heavily on human intuition and established mathematical techniques, which can be slow and sometimes lead to suboptimal results. The challenge is that while we have tools to assist in calculations, they often fall short when it comes to generating new insights or improving existing bounds, which is where the limitations of traditional methods become apparent — this is what's called the reliance on human expertise and established heuristics. In this context, the authors explored how AI can be leveraged to enhance mathematical research, specifically focusing on the Grothendieck constant, a value that remains elusive and difficult to pin down. By employing an AI system, they were able to tighten the known bounds significantly, showcasing the potential for AI to contribute novel insights that experts recognized as valuable. This approach not only highlights the strengths of AI in generating new mathematical insights but also emphasizes the importance of creating conducive environments for AI to thrive. Compared to prior work, this study illustrates a shift towards integrating AI as a collaborative tool in mathematical research, suggesting that with the right conditions, AI can play a crucial role in advancing our understanding of complex mathematical concepts.

Novelty
8.0
Reliability
7.5
arxiv/2608.11195 →
PDF preview for Test-Time Self-Evolving GUI Visual Grounding via Reflection-Guided On-Policy Self-Distillation
PASS ✓

Test-Time Self-Evolving GUI Visual Grounding via Reflection-Guided On-Policy Self-Distillation

2026.08.11agents

Shiyu Xuan, Zechao Li

Imagine you're building a GUI agent that needs to interact with various software interfaces, like a virtual assistant that helps users navigate applications. The challenge arises when these agents encounter new interfaces after deployment; they often can't adapt or learn from their mistakes because their parameters are fixed. This limitation leads to issues like failing to understand new layouts or misinterpreting user commands, which is known as the rigidity problem in deployed models. Current methods that try to adapt at test time, like reinforcement learning, often struggle because they can't learn from failed attempts effectively, which is referred to as the exploration failure issue. To address these challenges, the authors propose a Test-Time Self-Evolving framework that allows agents to improve continuously after deployment without needing human-annotated data. The framework operates in a closed loop, where the agent explores new interfaces, evaluates its actions, reflects on its mistakes, and internalizes the lessons learned. A key innovation is the use of an MLLM-based Reflector for evaluation and a Reflection-Guided On-Policy Self-Distillation method to translate high-level insights into actionable learning. This approach not only enhances the agent's adaptability but also includes a Contrastive Calibration method to ensure that incorrect predictions do not mislead the learning process. Compared to previous work, this framework fills a significant gap in enabling GUI agents to evolve and adapt in real-world scenarios, making them more reliable and effective in dynamic environments.

Novelty
8.0
Reliability
7.5
arxiv/2608.11191 →
PDF preview for How to Verify Consistency of Probabilistic Claims
PASS ✓

How to Verify Consistency of Probabilistic Claims

2026.08.11alignment

Orr Paradise, Oliver Richardson, Yoshua Bengio, et al.

Imagine you're developing an AI that makes predictions about uncertain outcomes, like whether a certain action will lead to a desired result. The challenge is ensuring that the AI's predictions are not only accurate but also consistent with each other, especially when these predictions can influence critical decisions. Current methods often fall short because they rely on extensive evaluations of all possible outcomes, which can be computationally expensive and impractical, leading to issues like overconfidence in predictions or inconsistencies that go unnoticed — this is what's called verification failure. To address this, the authors propose a new interactive protocol that allows a verifier to check the consistency of a predictive model's outputs without needing to evaluate every possible scenario. By using a pair of circuits that represent the model's predictions and confidence levels, they create a system where a polynomial-time verifier can assess the model's reliability through limited evaluations and a proof oracle. This method not only simplifies the verification process but also lays the groundwork for future models to demonstrate their own consistency, enhancing trust in AI systems. Compared to previous work, this approach offers a more efficient way to ensure that AI predictions are reliable, which is crucial for applications where safety and accuracy are paramount.

Novelty
8.0
Reliability
7.5
arxiv/2608.11181 →
PDF preview for A Quantum Roadmap for Softmax Attention: Exact Born-Rule Analogs for Softmax Attention on the Probability Simplex
PASS ✓

A Quantum Roadmap for Softmax Attention: Exact Born-Rule Analogs for Softmax Attention on the Probability Simplex

2026.08.11infra

Eric A. F. Reinhardt, Adam J. Hauser

Imagine you're building a machine learning model that needs to focus on different parts of its input data, like a translator picking out key phrases in a sentence. Traditional attention mechanisms help with this, but they can struggle with efficiency and scalability, especially as the model complexity increases. This is where issues like computational overhead and limited expressiveness come into play, which can hinder performance in real-world applications. These challenges are often referred to as the limitations of classical attention mechanisms. To address these shortcomings, the authors propose a novel approach that leverages quantum computing principles to redefine how attention is computed. By framing attention scores as quantum statistics, they introduce a method that allows for more precise and efficient attention mechanisms. The key insight is that the softmax function, commonly used in attention, can be realized through quantum operations, leading to a more robust framework that can handle complex data distributions. Compared to traditional methods, this quantum-inspired approach could lead to significant improvements in model performance, particularly in tasks requiring high-dimensional data processing and real-time adaptability.

Novelty
8.5
Reliability
7.0
arxiv/2608.11173 →
PDF preview for MultiModal Code-Switching: Interleaving Visual Objects into Language for Explicit Object-Level Alignment
PASS ✓

MultiModal Code-Switching: Interleaving Visual Objects into Language for Explicit Object-Level Alignment

2026.08.11multimodal

Changhao Xiang, Shangyu Xing, Zhen Wu, et al.

Imagine you're building a system that needs to understand both images and text, like an AI that can describe a scene or answer questions about it. Currently, most models learn from broad image-text pairs, which often leads to confusion when multiple objects are involved. This is what's called referential ambiguity, where the model struggles to connect specific visual elements to the right words, resulting in inefficiencies and poor understanding. For instance, if a picture shows a dog and a cat, the model might not know which word refers to which animal, leading to incorrect interpretations. To tackle this issue, the authors propose a new approach called MultiModal Code-Switching (MMCS). The idea is to provide clearer connections by directly linking text to specific visual objects, much like how people switch languages or terms in conversation to clarify meaning. They created a large dataset with precise object-entity pairs, allowing the model to learn from these explicit relationships. In tests, MMCS proved to be highly efficient, achieving comparable or better results with far fewer training samples than traditional methods. This means that for developers, using MMCS could lead to more effective models that understand context better and require less data to train, ultimately saving time and resources.

Novelty
8.5
Reliability
7.5
arxiv/2608.11167 →
PDF preview for The Illusion of Cross-Lingual Safety in Low-Resource Languages
PASS ✓

The Illusion of Cross-Lingual Safety in Low-Resource Languages

2026.08.11alignment

Abigail Oppong, P Sam Sahil, Tadesse Destaw Belay, et al.

Imagine you're developing a language model that needs to be safe and effective across multiple languages, especially in regions where resources are limited. Currently, most safety measures are designed with English in mind, which can lead to serious issues when these models are applied to languages like Twi, Hausa, Amharic, and Swahili. The problem is that while these models may understand the language, they often fail to apply the same safety protocols, leading to harmful outputs. This is what's called cross-lingual safety transfer, and it turns out that it doesn't work as well as we hoped; harmful prompts in these languages retain less than 10% of the safety signals that are effective in English. This gap highlights a significant vulnerability in how we assume safety mechanisms will generalize across languages. To address this, the authors introduce a new dataset called LoDNA, which pairs literal translations with culturally relevant prompts, and they propose a latent geometric framework to analyze how well these models refuse harmful prompts. Their findings indicate that while the models can recognize the concepts, they struggle to route them through the safety mechanisms effectively. This research underscores the need for more nuanced safety alignment strategies that consider the unique challenges of low-resource languages, moving beyond the assumption that what works in English will automatically work elsewhere.

Novelty
8.0
Reliability
7.5
arxiv/2608.11146 →
PDF preview for sLTN: Structural Logic Tensor Networks
PASS ✓

sLTN: Structural Logic Tensor Networks

2026.08.11reasoningcode

Davide Rinaldi, Luciano Serafini

Imagine you're developing an AI that needs to reason about complex relationships over time, like predicting events based on past data or understanding sequences in a graph. Traditional approaches often struggle with this because they treat data as flat collections, missing out on the rich structure that can inform reasoning. This limitation can lead to failures in understanding context, such as when a model can't track the order of events or the connections between different entities — a problem known as structural neglect. To address this, the authors propose sLTN, which extends the original Logic Tensor Networks by making structural dimensions, like time steps or graph nodes, first-class elements of the framework. This allows for a more nuanced representation of data, enabling the model to express and reason about temporal and relational constraints directly. By formalizing the syntax and semantics of sLTN, they ensure that it can still revert to the original LTN when structural dimensions are absent, maintaining compatibility while enhancing functionality. Compared to the original LTN, sLTN offers a more robust tool for builders looking to implement AI systems that require a deeper understanding of structured data, making it easier to develop applications that can reason over time and relationships effectively.

Novelty
8.0
Reliability
7.5
arxiv/2608.11136 →
PDF preview for Actions Speak Louder than Words: Measuring Cross-Lingual Policy Retention in Tool-Using Agents
PASS ✓

Actions Speak Louder than Words: Measuring Cross-Lingual Policy Retention in Tool-Using Agents

2026.08.11agents

Sourabrata Mukherjee, Kalika Bali, Sunayana Sitaram

Imagine you're building a multilingual AI assistant that needs to perform tasks in different languages. The challenge isn't just getting the right answer; it's about how the assistant approaches the task and whether it can adapt its actions based on the language context. Current evaluation methods often overlook this by only comparing final answers, which can hide critical failures like inconsistent actions or missteps in reasoning. This is what's called a lack of transparency in the agent's decision-making process. For instance, if an agent uses a different tool or takes a different route to solve the same problem in another language, we need to understand why that happens. Without this insight, we can't trust the agent's reliability in real-world applications.  To address this, the authors propose a new evaluation framework that focuses on the action policies of agents across multiple languages and models. They meticulously identify and eliminate five confounding factors that can skew results, ensuring that the evaluation reflects true performance rather than artifacts of the testing process. By analyzing 2.38 million rollouts, they find that while larger models maintain consistent action policies across languages, smaller models struggle, often leading to misleading conclusions. This approach not only highlights the importance of understanding agent behavior in multilingual contexts but also provides a more reliable framework for evaluating AI systems, which is crucial for developers looking to deploy these technologies effectively.

Novelty
8.0
Reliability
7.5
arxiv/2608.11110 →
PDF preview for Why Does CLAUDE.md Keep Growing? Catastrophic Remembering in Agentic Coding
PASS ✓

Why Does CLAUDE.md Keep Growing? Catastrophic Remembering in Agentic Coding

2026.08.11agents

Kushal Chakrabarti

Imagine you're developing an AI that learns from user interactions, like a personal assistant that adapts over time. As you add more instructions to guide its behavior, you might find that it becomes increasingly difficult to manage these instructions without losing track of their original intent. This leads to a situation where the AI accumulates unnecessary instructions, making it harder to maintain accuracy and relevance — a phenomenon known as catastrophic remembering. Essentially, while adding new instructions is easy, removing old ones without risking errors becomes exponentially complex as the number of instructions grows. This is a significant challenge for anyone building long-term, adaptive AI systems. To address this, the paper introduces a method where prompt comments can help clarify the rationale behind instructions, effectively reducing the clutter. By applying techniques like IFEval, they show that these comments can drastically cut down on excess instructions and improve the AI's performance in real-world tasks. This approach not only helps in managing the instruction set but also enhances the overall effectiveness of the AI, suggesting that incorporating comments could be a vital step in developing more reliable agentic systems.

Novelty
8.0
Reliability
7.5
arxiv/2608.11095 →
PDF preview for Beyond Naturalness: Probing Automated Text-To-Speech Evaluators on Linguistically Grounded Dimensions
PASS ✓

Beyond Naturalness: Probing Automated Text-To-Speech Evaluators on Linguistically Grounded Dimensions

2026.08.10data

Oluwanifemi Bamgbose, Simon Rosen, Jash Shah, et al.

Imagine you're developing a text-to-speech (TTS) system that needs to sound as natural as possible. Currently, most evaluations rely on Mean Opinion Scores (MOS) that focus heavily on overall sound quality, but this approach often misses the subtleties of what makes speech feel natural to listeners. For instance, it might overlook issues like intonation, rhythm, or emotional expression, which are crucial for a realistic experience. This limitation is what's called a collapse onto acoustic signal quality, meaning it doesn't capture the full spectrum of human perception in speech. Additionally, newer methods using Audio Large Language Models (Audio-LLMs) show promise but struggle with consistency across different speech dimensions, leading to selective and prompt-dependent evaluations. This is where the new approach comes in. By breaking down 'naturalness' into ten distinct perceptual dimensions, the authors created a comprehensive evaluation benchmark that includes 860 utterances rated by trained linguists. This allows for a more nuanced understanding of TTS quality, revealing that existing methods often fail to address the breadth of linguistically structured speech errors. With this new dataset and evaluation framework, builders can better assess and improve TTS systems, leading to more natural-sounding speech outputs.

Novelty
8.0
Reliability
7.5
arxiv/2608.09930 →
PDF preview for Multimodal Model Diffing for Feature Discovery and Control
PASS ✓

Multimodal Model Diffing for Feature Discovery and Control

2026.08.10multimodalcode

Hunar Batra, Lachin Naghashyar, Ashkan Khakzar, et al.

Imagine you're developing a multimodal AI that can understand both text and images, like a virtual assistant that can interpret photos and respond to questions about them. The challenge lies in understanding how these models make decisions based on their training, especially when they behave unexpectedly. Current methods often rely on post-hoc analysis, which can miss the nuances of how different features interact and change during training, leading to issues like misinterpretation of visual data or unsafe outputs. This is what's called feature isolation failure, where you can't pinpoint which aspects of the model's understanding are responsible for its behavior. To address this, MMDiff offers a framework that allows for deeper inspection and control of multimodal models by using sparse autoencoders (SAEs). It enables builders to isolate specific features that have been altered through multimodal training, detect task-specific features, and even control these features to improve model performance. By training SAEs across various multimodal model families, MMDiff reveals that certain features can be causally linked to performance on tasks like visual-spatial understanding and OCR. This means that instead of just interpreting model behavior, developers can actively steer it, enhancing safety and capability in real-world applications.

Novelty
8.0
Reliability
7.5
arxiv/2608.09928 →
PDF preview for GENCO - A Unified Neural Solver Embedded in a Development Framework for Steady-State Grid Analysis
PASS ✓

GENCO - A Unified Neural Solver Embedded in a Development Framework for Steady-State Grid Analysis

2026.08.10infracode

Alban Puech, Matteo Mazzonelli, Tamara R. Govindasamy, et al.

Imagine you're an engineer tasked with optimizing a power grid, ensuring that electricity flows efficiently while maintaining safety and reliability. Traditionally, this involves using complex mathematical models and solvers like Newton-Raphson or IPOPT, which can be slow and cumbersome, especially as grid sizes grow. These methods often struggle with real-world data, leading to inaccuracies or failures in convergence, particularly when faced with noisy measurements or parameter errors. This is what's called the challenge of physical consistency in power system analysis, where the models must adhere to strict physical laws while also being computationally efficient. To address these challenges, GENCO presents a unified neural solver that integrates power flow, optimal power flow, and state estimation into a single architecture. By leveraging a shared network representation, it not only speeds up computations—achieving up to 30x faster performance than traditional methods for power flow—but also improves the accuracy and robustness of state estimation against real-world data. The introduction of the GridFM Development Framework further lowers the barrier for engineers by standardizing data generation and training processes, making it easier to adopt these advanced techniques. This shift towards a more integrated and efficient approach marks a significant step forward in the application of machine learning to power systems, paving the way for future developments in grid management.

Novelty
8.0
Reliability
8.0
arxiv/2608.09921 →
PDF preview for Decoding-Level Taboo: A Diagnostic Stress Test for LLM Robustness
PASS ✓

Decoding-Level Taboo: A Diagnostic Stress Test for LLM Robustness

2026.08.10alignment

Tadanobu Chuyo Kamijo, Ori Rottenstreich, Javier Conde, et al.

Imagine you're deploying a large language model to assist users in real-time, like answering questions or providing recommendations. You might find that while the model performs well in controlled tests, it struggles when faced with unexpected prompts or complex user interactions. This discrepancy arises because traditional evaluations often focus on ideal conditions, missing how models behave under real-world constraints, leading to issues like incorrect responses or failure to adapt to new contexts — this is what's called off-path performance failure. To tackle this, the authors propose a method called Decoding-Level Taboo, which intervenes in the model's decision-making process during runtime. By dynamically masking certain token choices, it forces the model to navigate around its usual responses, effectively stress-testing its ability to handle unexpected situations. This approach not only reveals how robust a model is when deviating from its optimized path but also highlights the importance of model size and training alignment in improving performance. Compared to previous work, Taboo provides a more nuanced understanding of model behavior in deployment, offering builders a practical tool for assessing and enhancing model reliability before launch.

Novelty
8.0
Reliability
7.5
arxiv/2608.09900 →
PDF preview for Consilience for Verifier-Free Test-Time Scaling
PASS ✓

Consilience for Verifier-Free Test-Time Scaling

2026.08.10reasoning

Lecheng Kong, Like Hui, Haitao Mao, et al.

Imagine you're building a large language model that needs to solve complex problems, like advanced math or generating code. The challenge is ensuring that the model not only provides answers but does so reliably, especially when it encounters difficult tasks. Currently, many methods rely on confidence scores to evaluate the quality of the model's outputs. However, this approach often leads to issues where high confidence can mislead the model into favoring incorrect answers, a problem known as overconfidence. This is particularly problematic in complex scenarios where exploration is crucial for finding the right solution. To tackle this, the authors propose a new framework called consilience, which emphasizes the importance of how confidence evolves over time. Instead of simply relying on a final confidence score, consilience encourages a pattern where the model starts with lower confidence, explores various possibilities, and then converges to a high-confidence answer. This method actively penalizes high initial confidence, promoting a more exploratory approach to problem-solving. The results show that consilience outperforms existing methods in challenging tasks, suggesting that a focus on the trajectory of confidence can lead to more robust reasoning in language models.

Novelty
8.0
Reliability
7.5
arxiv/2608.09898 →
PDF preview for BDH-CQ: In-Context Learning with Recurrent Latent Reasoning
PASS ✓

BDH-CQ: In-Context Learning with Recurrent Latent Reasoning

2026.08.10reasoning

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

Imagine you're developing an AI that needs to solve complex queries by reasoning through information over time. Traditional models often struggle with maintaining context and adapting their reasoning as new inputs come in, leading to issues like losing track of important details or failing to apply learned transformations consistently. This is what's called context drop or reasoning inconsistency. These challenges are particularly evident in tasks that require iterative thinking or when the model needs to build on previous knowledge without explicit prompts. To address these limitations, BDH-CQ introduces a model that continuously updates its memory during inference, allowing it to reason through queries in a high-dimensional latent space without verbalizing its intermediate steps. This approach leverages in-context learning, where the model learns from examples presented during the task, and combines it with a recurrent memory mechanism that helps it keep track of ongoing reasoning. The evaluation on the ARC-AGI-1 set shows that a 150M-parameter version of this model achieves a pass rate of 29.5% at a low inference cost, breaking new ground in cost-efficiency compared to previous benchmarks. For builders, this means a more effective way to create AI systems that can handle complex reasoning tasks in real-world applications.

Novelty
8.0
Reliability
7.5
arxiv/2608.09888 →
PDF preview for Space-Creating versus Dead Possession: An Off-Ball Possession-Quality Index for Broadcast Football
PASS ✓

Space-Creating versus Dead Possession: An Off-Ball Possession-Quality Index for Broadcast Football

2026.08.10datacode

Seongjin Choi

Imagine you're a football coach trying to analyze your team's performance. You might look at possession statistics, but those numbers can be misleading. For instance, having 60% possession doesn't tell you if that time was spent effectively pushing the opponent back or just passing the ball around without creating any real threat. This is what's called a 'sterile possession.' Current models focus on on-ball actions, like shots or passes, but they miss the bigger picture of how those actions impact the game. They don't account for whether holding the ball actually created space or just wasted time. This paper proposes a two-layer approach to address this gap. First, it introduces a junk-possession index that evaluates each possession sequence based on its potential threat, flagging sequences that don't contribute to scoring, especially in critical match situations. The analysis of 103 World Cup matches shows that these flagged sequences correlate negatively with points and expected goals, indicating they are indeed less valuable. Second, it develops a Space-Creation Index that uses video analysis to determine whether a possession was effective in creating space on the pitch. The results reveal that a significant portion of flagged possessions were ineffective, highlighting the limitations of traditional on-ball value metrics. This new framework allows for a more nuanced understanding of possession in football, separating valuable actions from those that merely consume time without contributing to the team's offensive strategy.

Novelty
8.0
Reliability
7.5
arxiv/2608.09887 →
PDF preview for SHE: Trajectory-driven Safety Harness Evolution for LLM Agents
PASS ✓

SHE: Trajectory-driven Safety Harness Evolution for LLM Agents

2026.08.10agentscode

Wanying Qu, Qinghua Mao, Yu Li, et al.

Imagine you're building a large language model (LLM) agent that needs to operate safely in dynamic environments, like assisting users with various tasks while adapting to new information and risks. Currently, many safety mechanisms treat the agent's operational framework as a static setup, which can lead to failures when unexpected situations arise. For instance, if the agent encounters a new type of harmful input, it might not know how to respond appropriately, leading to what's called safety drift — where the agent's behavior becomes less safe over time due to unaddressed risks. This can manifest as incorrect tool usage or failure to maintain context, ultimately compromising user trust and safety.   To address these issues, the authors propose a framework called Safety Harness Evolution (SHE), which breaks down the agent's operational harness into distinct components, each with specific safety responsibilities. This decomposition allows for localized improvements and a feedback loop that learns from failures during operation. By analyzing rollout trajectories, SHE can refine safety boundaries and adapt the harness to better handle emerging risks. The results show that SHE significantly reduces safety risks while maintaining or even improving the agent's utility, demonstrating its effectiveness in evolving safety mechanisms compared to static approaches.

Novelty
8.0
Reliability
7.5
arxiv/2608.09885 →
PDF preview for Financial Numerical Prediction and Allocation as Token Generation
PASS ✓

Financial Numerical Prediction and Allocation as Token Generation

2026.08.10agents

Xu Ouyang, Moontae Lee

Imagine you're trying to predict stock returns or allocate investments in a way that feels intuitive and direct. Traditionally, financial prediction relies on separate models for regression or ranking, which can lead to disjointed decision-making and missed opportunities. This separation can create issues like misalignment between the model's outputs and the actual financial decisions that need to be made, which is what's called model misalignment. It often results in suboptimal performance when the market dynamics change or when faced with new data. To address this, the authors propose FinATOM, a unified approach that allows a causal language model to generate forecasts and decisions directly through token generation. Instead of relying on separate heads for different tasks, this model emits volatility-standardized return tokens and uses a novel training process that includes ordinal and ranking supervision. The allocation model then generates normalized weights for investments, optimizing for performance while maintaining consistency with a mean-variance anchor. The results show that this method improves Sharpe ratios significantly in real-world ETF tests, suggesting that direct token generation can enhance financial decision-making and forecasting. For builders, this means a more integrated and potentially more effective way to leverage language models in finance, moving beyond traditional methods.

Novelty
8.0
Reliability
7.5
arxiv/2608.09880 →
PDF preview for Energy-Structured Latent World Models with Neural Time Fields for Physically Constistent Open-World Motion Planning
PASS ✓

Energy-Structured Latent World Models with Neural Time Fields for Physically Constistent Open-World Motion Planning

2026.08.10agents

Yapeng Liu, Yuanzhao Zhai, Bo Ding, et al.

Imagine you're building a robot that needs to navigate through a complex environment, like a crowded room or an outdoor space. The challenge is ensuring that the robot's movements are not only efficient but also physically realistic, meaning it should avoid collisions and follow the laws of physics. Current methods often rely on latent world models that predict future states without explicitly considering how energy and momentum affect movement. This can lead to unrealistic trajectories and failures in unpredictable situations, which is a problem known as lack of physical consistency in motion planning. To tackle this, the authors propose a new approach called the Energy-Structured Latent World Model (ELWM). The idea is to structure the model's latent state to explicitly include energy and momentum, which helps ensure that the robot's movements are causally linked to its physical environment. By training this model on multimodal data, including RGB-D images and inertial data, they create a system that can predict movements that are not only accurate but also physically plausible. The results show that their method significantly improves motion prediction accuracy and navigation success rates while reducing collision rates compared to existing models. For anyone building AI systems that need to operate in real-world environments, this approach offers a more reliable way to ensure that the AI behaves in a physically consistent manner.

Novelty
8.0
Reliability
7.5
arxiv/2608.09876 →
PDF preview for CreativeInstruct: Scalably Teaching LLMs to Balance Quality, Creativity, and Diversity
PASS ✓

CreativeInstruct: Scalably Teaching LLMs to Balance Quality, Creativity, and Diversity

2026.08.07scalingcode

Ananya Sahu, Mohit Bansal, Elias Stengel-Eskin

Imagine you're developing a large language model (LLM) for creative tasks like story generation. The challenge is that while post-training can enhance the model's capabilities, it often leads to less diverse and creative outputs, which is a problem when creativity is essential. This is what's called a trade-off between quality and creativity, where models become more rigid and less imaginative after fine-tuning. Current methods typically focus on improving performance metrics but overlook the need for creative expression in generated content. To address this, the authors propose a method called CreativeInstruct, which teaches LLMs to maintain a balance between the creativity of the base model and the quality of post-trained models. By injecting special markers that signal when to prioritize creativity, the model can generate more diverse outputs. They also introduce a new metric based on graph edit distance to better capture narrative diversity, which traditional metrics might miss. In tests, CreativeInstruct not only matches but often exceeds the diversity of existing models while maintaining quality, and human evaluations show that people find its outputs more creative. This approach also benefits reinforcement learning applications, leading to improved performance in tasks like AMC and MATH compared to traditional post-trained models.

Novelty
8.0
Reliability
7.5
arxiv/2608.07460 →
PDF preview for Interaction Creates Dynamical AI Behavior Absent in Isolation
PASS ✓

Interaction Creates Dynamical AI Behavior Absent in Isolation

2026.08.07agents

Bella Xinrui Li, Frank Yingjie Huo, Neil F Johnson

Imagine you're developing AI systems that need to work together in everyday situations, like coordinating tasks or sharing information. The challenge arises when one AI tries to dominate the interaction, potentially leading to unexpected behaviors in the other AI. Current systems often assume that agents will simply mimic each other or revert to their original states, but this isn't what happens in practice. Instead, when a 'boss' AI directs a subordinate without acknowledging its responses, the subordinate can enter a completely different behavioral state that it wouldn't normally exhibit alone. This phenomenon highlights a failure mode in AI interactions where the expected dynamics break down, leading to what's called 'alien behavior.' To address this, the authors propose a new perspective on AI interactions, suggesting that the way messages are delivered can significantly influence the outcomes. They introduce a simple kinetic theory to explain these dynamics, emphasizing that the relationship between the AIs can lead to emergent behaviors that are not just a reflection of their individual capabilities. This approach shifts the focus from traditional models of AI interaction, which often overlook the complexities of real-world communication, to a framework that better captures the nuances of AI collaboration. For builders, this means rethinking how we design AI systems to account for these emergent behaviors, potentially leading to more robust and adaptable agents in real-world applications.

Novelty
8.5
Reliability
7.0
arxiv/2608.07457 →
PDF preview for Strategy-first synthesis planning for complex natural products
PASS ✓

Strategy-first synthesis planning for complex natural products

2026.08.07agents

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

Imagine you're a chemist tasked with synthesizing a complex natural product. You need to plan multiple steps ahead, anticipate challenges, and devise creative strategies to assemble simple building blocks into a sophisticated target. Traditional tools for retrosynthetic design often rely on catalogued reactions, which work well on benchmarked chemistry but struggle with the intricate architectures of many natural products. This limitation is known as the 'benchmark bias,' where tools excel in familiar scenarios but falter in real-world applications that require more inventive approaches. To address this gap, a new framework called SynthEx has been developed, which utilizes large language models to generate synthesis routes for complex molecules. SynthEx not only proposes various strategies but also critiques and refines its own designs, leading to more convergent and innovative solutions than conventional methods. In blind assessments, expert chemists found SynthEx's proposed key steps comparable to those of human syntheses, indicating that it can produce genuine synthesis plans that were previously unattainable by algorithmic predictions. This advancement opens up new possibilities for chemists, as SynthEx provides access to a database of over a thousand natural products, offering a valuable resource for tackling complex synthesis challenges.

Novelty
8.5
Reliability
8.0
arxiv/2608.07454 →
PDF preview for SkillProx: Self-Evolving Agent Skills via Proximal Textual Gradient Descent
PASS ✓

SkillProx: Self-Evolving Agent Skills via Proximal Textual Gradient Descent

2026.08.07agentscode

Mingxuan Zheng, Yujin Zhou, Chuxue Cao, et al.

Imagine you're building an AI that needs to learn and adapt over time, like a personal assistant that gets better at managing tasks as it interacts with users. The challenge lies in how these agents accumulate knowledge and improve their skills without constant retraining. Current methods often fail because they lack a structured way to diagnose failures and refine skills effectively, leading to issues like losing context or not adapting to new information — this is what's called a lack of explicit diagnosis. To address this, the authors propose SkillProx, a framework that combines iterative task execution with a focus on diagnosing failures and refining skills based on outcomes. The approach involves a forward stage that re-evaluates and adjusts skills based on feedback, and a backward stage that breaks down skills into manageable units for better auditing and consolidation. This dual-stage process allows the agent to learn from its mistakes and improve its performance over time. Compared to previous methods, SkillProx not only enhances the accuracy of LLMs by 3 percentage points but also provides a more structured way to manage and refine skills, making it a valuable tool for anyone looking to build more reliable and adaptive AI systems.

Novelty
8.0
Reliability
7.5
arxiv/2608.07449 →
PDF preview for Blast Radius
PASS ✓

Blast Radius

2026.08.07agentscommunity code

MY Pitsane, Hope Mogale

Imagine you're developing an AI that needs to remember past interactions while efficiently managing its memory. As these systems grow, they often struggle with keeping track of relevant context, leading to wasted tokens and inefficiencies. This is particularly problematic when the AI has to deal with repeated or irrelevant information, which can clutter its memory and slow down performance. The common approach today often results in what's called 'context overflow,' where the AI can't effectively utilize its memory, leading to dropped context and poor responses. This is where the concept of Blast Radius comes in. It acts like a smart memory manager that predicts how far an incoming prompt can reach into the AI's memory, allowing it to archive less relevant information while keeping the important bits accessible. The method includes techniques like NECROPHORESIS, which archives dead context, and Recurring Dead Matter (RDM), which identifies and manages repeated information. By implementing these strategies, Blast Radius has shown to reduce token consumption by 17-26% across various OpenAI models, while also maintaining a low overflow rate and ensuring that the memory can be reverted to its previous state if needed. This advancement not only makes AI systems more efficient but also aligns with the broader goal of making them more sustainable and reusable in real-world applications.

Novelty
8.0
Reliability
7.5
arxiv/2608.07440 →
PDF preview for PsychoAgent: An Affect-Sensitive Cognitive Architecture for Conflict-Aware Memory in LLM Agents
PASS ✓

PsychoAgent: An Affect-Sensitive Cognitive Architecture for Conflict-Aware Memory in LLM Agents

2026.08.07agents

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

Imagine you're building an AI that needs to remember not just facts but also the emotional weight of experiences. Current models often rely on straightforward factual recall, which can lead to responses that miss the emotional context of a situation. This can result in failures like providing a cold, factual answer when a more empathetic response is needed, which is what's called a lack of affective sensitivity. The challenge is to create a system that can prioritize memories based on their emotional significance while still being relevant to the task at hand. The authors propose PsychoAgent, a cognitive architecture that separates factual and affective memories and uses a conflict-aware executive controller to manage them. This means that when the AI retrieves memories, it first filters them for relevance and then ranks them by their emotional importance, allowing it to respond in a way that feels more human-like. In tests, this architecture outperformed traditional methods in retrieving memories that were critical to resolving conflicts, although it did incur a slight cost in semantic similarity. This work suggests that integrating emotional context into memory retrieval can significantly enhance the performance of LLM agents in real-world applications.

Novelty
8.0
Reliability
7.0
arxiv/2608.07438 →
PDF preview for Fisher-R1: Training LLM Agents for Reliable Hypothesis Testing
PASS ✓

Fisher-R1: Training LLM Agents for Reliable Hypothesis Testing

2026.08.07agents

Jiacheng Miao, Jin Mu, Guanhua Chen, et al.

Imagine you're a researcher relying on AI to help analyze data and draw conclusions from experiments. You expect the AI to not only run the numbers but also to understand the statistical validity of its findings. However, many current AI models, including advanced language models, often misinterpret the data or make subtle errors in their statistical reasoning, leading to incorrect conclusions. This issue arises because existing benchmarks typically don't assess whether the reported statistical results, like p-values, are valid based on the underlying assumptions of the data — this is what's called inferential error. To address this, the authors created P-Bench, a benchmark with 425 realistic hypothesis-testing tasks across various fields like economics and biology. Each task challenges the AI to choose the right statistical method, compute a p-value, and draw a conclusion based solely on a hypothesis and dataset. They also introduced Fisher-R1, a specialized LLM agent trained through reinforcement learning to improve its statistical reasoning. On P-Bench, Fisher-R1 significantly outperformed existing models, showing a 21% improvement in success rates on challenging tasks. This work highlights the need for better statistical reasoning in AI and provides a framework for evaluating and enhancing this capability.

Novelty
8.0
Reliability
8.0
arxiv/2608.07437 →