Week beginning 2nd November 2026

Every computer science paper posted to arXiv this week, with plain-language summaries and practical uses for each one. Includes commercial applications where relevant.

User embeddings reveal clear behavioral patterns for better personalization

User Embeddings are Superpositions of Interpretable Behavioral Modes

Abstract: User embeddings are central components of modern recommendation, personalization, and behavioral modeling systems. Though these embeddings can compactly encode rich behavioral information, they are inherently dense and opaque, limiting interpretability. To address this gap, we argue that user embeddings can be understood as sparse superpositions of interpretable behavioral modes. This structure is directly predicted by generative models of user behavior for linear embeddings and extends approximately to deep-learning representations by the superposition hypothesis. Superimposed modes can naturally be recovered by sparse dictionary learning methods, such as sparse autoencoders (SAEs), and recovered modes can be automatically named and queried in natural language. We validate mode recovery against known ground truth on synthetic data, where SAEs recover modes better than classical sparse baselines, including on transformer-encoded embeddings. We then apply the method to classical and transformer-based user embeddings from two real-world datasets. We also show how the corresponding natural-language labels enable zero-shot audience retrieval and characterization over embeddings never trained on text. The framework is post-hoc and model-agnostic, requiring no modification to the upstream embedding system.

Thu 5 NovMachine Learning
The gist
User embeddings are like digital fingerprints that capture how people behave online, but they are usually hard to understand because they mix many behaviors together. The authors show that these embeddings can be broken down into simpler parts that each represent a clear behavior mode, making them easier to interpret. They use special machine learning tools to find these behavior modes and even give them names using natural language. This helps to find and describe groups of users without needing extra text data. Their method works well on both fake and real user data and does not require changing the original embedding system.
Open → 2611.08487v1

Scientific figures clarity improves with AI but design still needs humans

Do You Miss the Nights We Spent Crafting Figures? Rethinking Teaser and Framework Figures in the Age of Generative AI

Abstract: Scientific figures give research ideas a visual form through choices of abstraction, composition, and emphasis. Generative AI offers new ways to realize these choices, raising questions about explanatory clarity and purposeful visual expression. We examine these questions through a visual retrospective of 371 motivation and framework figures from 200 papers. The corpus comprises a quota-based main sample of 160 papers spanning four temporal periods and a separate purposive style-contrast sample of 40 papers. A single multimodal judge evaluates six dimensions of communication and design, with three repeated judgments per figure. We attempt source-constrained revisions of all 371 figures, of which 369 pass the recorded fidelity checks. Original-figure ratings show no uniform decline across periods. Revisions increase mean clarity ratings by 0.428 points and decrease aesthetic coherence ratings by 0.111 points on a five-point scale. Gains in the six-dimension average are larger for main-sample motivation figures than for frameworks. Case analyses show that added explanation can clarify comparisons while leaving typographic hierarchy and visual economy unresolved. These model-based findings support researcher-led design, with AI assisting exploration and authors retaining responsibility for explanatory purpose, composition, and scientific relationships. The accompanying atlas and evaluation records are available at https://ntu-ai4x.github.io/Rethinking_Figures/index_en.html.

Thu 5 NovComputer Vision and Pattern Recognition
The gist
Scientists use pictures in papers to explain their ideas clearly. The authors studied hundreds of these pictures over time and tried improving them using AI while keeping the original meaning. They found AI can make figures easier to understand but sometimes less visually tidy. Their results suggest that AI can help researchers explore better designs, but people should still decide how to show information clearly and attractively.
Open → 2611.08486v1

Grounded reasoning works best for visual tasks needing indescribable references

Where and Why is Grounded Reasoning Useful?

Abstract: Grounded reasoning, where a model outputs text coordinates of relevant locations in chain-of-thought reasoning, is a common strategy for solving complex visual reasoning problems. However, the benefits and limitations of grounded reasoning are understudied. We study where and why grounded reasoning is most useful. To do so, we introduce a chain-of-thought analysis method to measure how much a model uses its outputted grounding in its thinking trace and perform a detailed ablation study of a grounded reasoning training recipe. We find that grounded reasoning improves counting but shows no significant gain over baselines without coordinate grounding across a wide range of spatial reasoning and perception benchmarks. Using several synthetic tasks, we show that grounded reasoning is most useful when a task requires undescribable references, which are visual concepts that are difficult to describe in language. However, we observe that many existing visual reasoning benchmarks are solvable with only describable text references. To close this gap, we introduce BrickVision, a new benchmark that requires undescribable visual references to solve.

Thu 5 NovComputer Vision and Pattern Recognition
The gist
Some computer models solve visual puzzles by pointing to important spots in images as they think through problems. The authors studied when this pointing, called grounded reasoning, really helps. They found it mainly improves counting objects but doesn’t offer much help in other common spatial tasks. Grounded reasoning shines when the task depends on visual details that are hard to put into words. To test this, the authors created a new challenge called BrickVision that needs these tricky visual clues to solve.
Open → 2611.08485v1

Agent swarms speed up discovery and improve math problem solutions

SwarmEvolve: Latent Agent Swarms for Evolutionary Discovery and Optimization

Abstract: LLM-guided evolutionary search uses AI agents to improve programs for mathematical and computational problems by iteratively refining solutions and combining high-scoring methods. However, the process is often slow because the LLM generates a long textual chain of thought for each round and must repeat this generation many times to maintain population diversity. We present SwarmEvolve, a framework in which hundreds of low-cost agents per round work in swarms, reason in latent space without decoding to text, and share information by passing KV caches. Each swarm studies the problem from a different angle. A novelty filter keeps the most distinct agent ideas by directly measuring the distances between the agents' hidden state vectors. Crossover of ideas happens naturally in latent space, as a summarizer agent receives the combined KV caches of all swarm members. On 21 problems in mathematical discovery and scientific computing, SwarmEvolve gets the highest average score and needs a median of only 3 to 8 minutes to reach the best scores that other state-of-the-art frameworks reach in 60 minutes. On several problems, SwarmEvolve with Qwen3 8B improves on the solutions that AlphaEvolve first found with frontier LLMs. Our work shows that agent swarms that communicate in latent space offer a fast, low-cost approach to program search for scientific problems.

Thu 5 NovArtificial IntelligenceNeural and Evolutionary Computing
The gist
Finding better program solutions for math and science problems can be very slow. The authors created a system where hundreds of simple AI agents work together in secret code form rather than text. These agents share ideas quickly, keep only the most unique ones, and combine their knowledge like a team brainstorming session. This new method solved challenging problems faster and better than previous AI approaches. It shows that teamwork inside hidden computer states can make scientific problem-solving more efficient.
Open → 2611.08483v1

Scientist world creates runnable environments for ai research papers

Scientist World: Grow a Research World for AI-Scientists

Abstract: AI-Scientists arrived, but a world for them to grow in did not. Human scientists take theirs for granted $-$ centuries of open problems and shared ideas, waiting in the scientific literature. To AI-Scientists, that world is readable but not runnable, so we build Scientist World for them: every research paper becomes an executable environment. Our autonomous pipeline extracts each paper's open-ended research question and reproduces its proposed method as the baseline; an AI-Scientist entering the environment is evaluated against what the human authors achieved. We release the first 1,000 verified environments. With the world as an evaluation, we found that frontier AI-Scientists can already surpass the human researchers 74% of the time. As a record of how AI does science, it contains 6,400 hours of research traces, with every idea, experiment, failure, and success. As a training ground, we are able to raise (+158%) a small model to match frontier models in research ideation. At last, AI-Scientists' own world has arrived, grown from and growing with science itself.

Thu 5 NovArtificial IntelligenceComputation and LanguageMachine Learning
The gist
AI researchers have tools to read scientific papers but can't easily run experiments from them. The authors built Scientist World, where every research paper is turned into an interactive environment an AI can explore and experiment within. This helps AI scientists test their ideas and improve over human results in many cases. The system also records all trials and outcomes, helping train better AI models for scientific discovery.
Open → 2611.08478v1

EgoGeneralist unifies egocentric video tasks with 3D action modeling

EgoGeneralist: Unifying Egocentric Action-Video Tasks through Video-Native Modeling

Abstract: Modern video models possess strong visual priors, yet do not natively represent human action in metric 3D space. We present EgoGeneralist, which adapts pretrained video generators to unify action-conditioned egocentric video generation, pose estimation, and joint action-video generation. Our role-adaptive action renderer provides video-native representations for multidirectional action-video learning, making metric motion usable as both a spatial control signal and a recoverable generation target. Cross-stream action-video coupling establishes close correspondence between metric motion and visual dynamics through lightweight adaptation while preserving the pretrained visual prior. Together, these designs establish a generalist framework spanning five action-video tasks. Despite adaptation only on controlled laboratory recordings, EgoGeneralist generalizes to diverse unseen scenes and interactions with effective action control and visual quality, bridging pretrained visual knowledge and metric 3D human motion.

Thu 5 NovComputer Vision and Pattern Recognition
The gist
Making sense of videos showing people’s actions from their own viewpoint is hard because computers usually don’t understand how bodies move in real 3D space. The authors created EgoGeneralist, a system that combines learning from videos with understanding 3D human motion to better generate, estimate, and relate actions seen from a first-person view. This method uses a special video-based approach to link visual motions and 3D movements, making it work well even on new types of scenes it wasn’t trained on. As a result, EgoGeneralist can handle many tasks involving egocentric action videos using one single model.
Open → 2611.08477v1

Semiring query interpretations cannot express SQL subtraction operation

Monus vs. Interpretations in Semiring Semantics

Abstract: Interpretations have been widely used in the study of provenance of queries on semiring-annotated databases. Here, we consider two different interpretation-based semantics for first-order formulas in negation normal form, namely, the canonical-interpretation semantics and the compatible-interpretation semantics. We show that the resulting query languages cannot express the monus operation on semiring-annotated relations, when the annotations come from the bag semiring or the tropical semiring or the fuzzy semiring. Consequently, the semantics of SQL cannot be captured using the interpretation-based semantics considered here.

Thu 5 NovDatabases
The gist
This paper looks at specific ways to understand how database queries work when the data includes extra information called semiring annotations. The authors find that two common interpretation methods for queries in such databases cannot perform the 'monus' operation, which is similar to subtraction. This means that these methods cannot fully capture how SQL handles certain operations. Their findings limit how these interpretation techniques can be used to represent database query semantics.
Open → 2611.08474v1

Benchmark measures migration of ML code between PyTorch and JAX

XStack: A Benchmark for ML Repo Migration

Abstract: ML code should run where researchers choose, not where it was first written. Today, machine learning code mainly lives in two ecosystems, PyTorch on NVIDIA GPUs and JAX on Google TPUs. Migrating repositories between them means building and testing across frameworks and hardware. This migration is (1) a practical need, since it unlocks different hardware for researchers, and (2) a natural benchmark: it involves different frameworks and hardware, covers whole repositories, and is long-horizon and challenging. We introduce XStack, a benchmark that evaluates agents on migrating ML repositories between these two ecosystems. Each agent receives a PyTorch repository and a clean TPU machine and must deliver a JAX repository. Its output passes if it meets our grading criteria, based on the source repository's published result, authenticated and calibrated by us. Migration by agents remains unreliable: Claude Opus 5 passes 75%, GPT-5.6-sol 45%, and every other agent at most 40%. XStack is a step toward freeing ML code from its ecosystem. We release XStack to make progress toward reliable migration across frameworks and hardware measurable.

Thu 5 NovMachine LearningArtificial Intelligence
The gist
Machine learning code is often written to run on specific hardware and frameworks, like PyTorch for NVIDIA GPUs or JAX for Google TPUs. Moving code from one setup to another is difficult but important for researchers who want to use different hardware. The authors created XStack, a test that checks how well computer programs can translate ML code from PyTorch to JAX on TPU machines. Their tests show that current tools are still unreliable at this task. XStack helps measure progress toward easier ML code portability.
Open → 2611.08472v1

Integrated information identifiability from limited experiments in stochastic networks

Same Behavior, Different Mechanism: What Finite Experiments Can Certify About Integrated Information

Abstract: Interpretability, AI auditing and assessments of machine consciousness increasingly rest on mechanism-level quantities: functionals of a system's causal transition law that describe how it computes, not what it outputs. Experiments see that law only through finite, partial and noisy interventions. We ask when such a quantity is identifiable from an experiment's access, continuous in the mechanism and certifiable from finite data, and answer exactly for a deliberately demanding case - the integrated information $\varphi$ of integrated information theory - in stochastic networks of four and five units with known ground truth. Behavior can be silent: a recurrent and a feed-forward network with identical input-output laws at their response delay carry 0.28 and 0 bits, yet internal recordings separate them within 4-53 trials. Partial access can be just as blind: in our examples, units left out of a one-step recording impose precision floors of 0.30-1.02 bits that no sample size lowers, and in all-but-self parity networks, recordings of any length see several hidden units only through the product of their fidelities - a symmetry that one intervention broke in exact checks. The measure has sharp edges: because $\varphi$ selects a partition, and the cause and effect it specifies, by one criterion and reports another, infinitesimal changes of mechanism that cross an edge change it by 25-100% at 99% of the edges we found in random networks, and about 1% of surrogate models that fit interventional data almost perfectly misreport it by more than 20%. One-sided claims survive: the same data certify a lower bound on both sides of an edge, and we prove $\varphi>1.004$ bits throughout a 64-dimensional region of mechanisms and certify it from about $10^7$ controlled transitions with false-certificate probability at most $α$. Measurability is thus a design question with computable answers.

Thu 5 NovMachine LearningArtificial Intelligence
The gist
Understanding how complex systems compute often depends on knowing their internal workings, not just what outputs they produce. The authors study when a specific measure of integrated information, which relates to how parts of a system causally interact, can be reliably inferred from limited and noisy experiments. They show that even systems with identical input-output behavior can have very different internal mechanisms, detectable with enough targeted trials. However, partial access to the system’s internal states can limit the precision of these inferences, sometimes significantly. Their work demonstrates that measuring such quantities precisely is possible but can be sensitive to subtle changes and requires careful experimental design.
Open → 2611.08469v1

Fast algorithm finds key graph partitions using max flow

Canonical Cut Hierarchy in Almost-Linear Time via Reduction to Max-Flow

Abstract: The canonical cut hierarchy recursively partitions a graph along Tutte-Nash-Williams partitions, choosing the partition with the most number of parts at each step. We give a randomized almost linear-time algorithm for computing this hierarchy in undirected graphs with polynomially bounded capacities via reduction to max-flow. This yields randomized almost linear-time algorithms for computing partition connectivity, strength, both arboricity and fractional arboricity, both integral and fractional spanning tree packing numbers, and implicit representations of the principal partition sequence and a maximum fractional spanning tree packing.

Thu 5 NovData Structures and Algorithms
The gist
Understanding how a network splits into parts is important in many areas like design and analysis. The authors developed a fast method that uses advanced math tools called max-flow to find a special way to break down a network into smaller groups. Their approach works quickly even on large networks and helps calculate different properties related to connectivity and tree structures inside the network. This can help people who deal with complex networks get useful information faster.
Open → 2611.08466v1

Language model metamodel finds text linked to model signals better than search

Towards interpreting any residual stream direction by scaling activation inversion

Abstract: To interpret a direction in a language model's residual stream, we can look for text that strongly activates it. But when such text is found by scanning a corpus, it is limited to what that corpus contains. We develop Maximally-Activating Example Metamodels (MAEMs), language models which map residual stream directions from a subject model to text exemplars that strongly activate those directions. Our objective is to maximise the cosine similarity of a supplied residual stream direction with the activations of the text generated by the MAEM. This label-free RL objective helps to scale MAEMs on diverse sources of residual stream directions. Empirically, we find the resultant metamodel produces informative exemplars: a Qwen3.6-27B MAEM inverts held-out activations better than corpus search or a natural-language autoencoder (NLA), beats corpus search (at 10M tokens) on a majority of held-out languages/domains, and activates 89% of held-out SAE features. It also identifies concepts behind steering vectors about as well as NLAs, recovers the payloads of LoRA backdoors more often than corpus search, and can even verbalise some model workspace inner monologue. Unlike explanations produced by other metamodels (e.g. NLAs), MAEM exemplars can be verified with a forward pass on the subject model, making the MAEM objective a grounded alternative for scaling the training of metamodels.

Thu 5 NovMachine LearningArtificial Intelligence
The gist
When large language models process text, they contain hidden signals that relate to meaning or intent, but these signals are hard to interpret. The authors created a special kind of language model called a MAEM that can take one of these hidden signals and generate example text that strongly activates it, even beyond what exists in a given text corpus. This helps explain what a particular hidden signal represents by showing text that causes the model to react in that way. Their approach worked better than just searching for text or using previous methods, and it can even reveal concepts behind model behavior or hidden backdoors.
Open → 2611.08465v1

Visual robotic models learn to fix mistakes from few examples

OopsieRecover: Learning Transferable VLA Corrections from Semantic Interventions

Abstract: Vision-Language-Action (VLA) models can perform a wide range of robotic manipulation tasks, but often fail during deployment. Teaching them to recover from these failures requires substantial corrective data: existing approaches learn to recover from failures by directly associating corrective actions with the observations in which they were demonstrated. For instance, DAgger-like fine-tuning can require tens to hundreds of interactions, yet the resulting policy may still fail to generalize the learned corrections beyond the demonstrated scenarios. We hypothesize that semantics can capture the underlying reasons for failures and their corrections, enabling policies to learn from only a handful of corrective demonstrations and generalize those corrections to novel objects, and scene variations. We propose OopsieRecover, a framework that uses abduction to infer the intent behind a small set of corrective demonstrations and encodes the inferred knowledge as dense spatial representations and conditional costs. These costs capture when a behavior is undesirable and steer the policy toward more desirable action regions. We experiment across 6 tasks and variations in object poses, scenes, and related tasks, and find that only a handful of corrective demonstrations can enable a VLA to overcome failures across a broad range of novel situations, without requiring new corrective data for each variation. Please refer to https://robin-lab.cs.utexas.edu/oopsierecover for videos.

Thu 5 NovRobotics
The gist
Robots that use vision and language to pick up objects can make mistakes when working in new environments. The authors show a way to help these robots learn to fix their mistakes by understanding the reasons behind errors instead of just memorizing fixes. Their system, called OopsieRecover, uses a small number of corrections and learns general rules that apply to new objects and scenes. This means robots can improve from fewer examples and adapt better to new tasks and places.
Open → 2611.08462v1

Latent rl priors improve learning hand manipulation from images

Latent RL Priors for Data-Efficient Dexterous Manipulation

Abstract: Learning dexterous manipulation from limited visual demonstrations is challenging because policies must acquire both perceptual grounding and precise control, while reinforcement learning (RL) in simulation can acquire rich control behaviors from large-scale interaction with privileged information. We introduce \textbf{Latent RL Prior}, a two-stage framework that reuses this control knowledge for data-efficient visual policy learning. During privileged pretraining, we distill large-scale RL rollouts into a flow-matching action decoder conditioned on proprioception and latent task context. During visual adaptation, we freeze the decoder and learn a visual interface that maps images to its latent context using action supervision alone, without privileged labels or latent targets. The same decoder can further be shared across arms by learning coordinated visual contexts for bimanual manipulation. Across three simulated tasks, our method outperforms full-parameter fine-tuning of $π_{0.5}$ and GR00T N1.7 in the low-data regime; on door lifting and bimanual assembly, it surpasses full-data baselines using $10\times$ and $5\times$ fewer demonstrations, respectively. Further analysis shows that direct visual-to-latent conditioning improves adaptation performance and training stability over routing visual predictions through the pretrained state encoder. Robustness to unseen mass variation and greater linear accessibility of contact-force information in decoder representations further provide evidence of retained RL-acquired control knowledge. Project website: https://yixiaowang7.github.io/latent-rl-prior-page/.

Thu 5 NovRobotics
The gist
Learning to control robotic hands from a few videos is hard because the robot must both understand what it sees and learn precise movements. The authors developed a two-step method that first teaches the robot control using full internal knowledge, then quickly adapts to work from images alone by mapping visuals to this learned control. This approach helps robots learn complex tasks like opening doors or assembling parts with fewer examples than other methods. Their techniques also improve how well the robot handles new situations and keep control knowledge reliable.
Open → 2611.08458v1

Gradient descent with large steps changes adversarial training behaviors

Adversarial Training with Large Step Sizes: Implicit Bias, Optimization, and Sharpness

Abstract: Adversarial Training (AT) is an important method for improving model robustness. We study the dynamics of deterministic Gradient Descent (GD) in AT. Most existing works in this direction focus on the small or vanishing step sizes regime, where GD resembles a continuous-time flow. However, such step sizes can make training inefficient and are rarely used in practice. In this paper, we study the AT dynamics of GD with large constant step sizes. We first study GD in adversarial linear logistic regression, focusing on two aspects: where the model parameters converge (implicit bias) and how quickly the losses decrease (optimization). We then turn to neural networks training and study how the sharpness of losses evolve during AT. Our results advance the understanding of the behaviors of GD with large step sizes in AT and highlight three key differences from its behavior in Standard Training (ST): (i) the implicit bias gap between AT and ST, previously established only for small step sizes, persists for arbitrarily large constant step sizes, (ii) different from ST, there is no uniform rate of convergence for the optimization error in AT, and (iii) sharpness can exhibit two-stage dynamics that differ from the Edge-of-Stability behavior observed in ST.

Thu 5 NovMachine Learning
The gist
Training computer models to be robust against tricky mistakes is important. The authors looked at how a common training method called gradient descent acts when taking big steps instead of very small ones, during a special kind of training called adversarial training. They found that certain behaviors, like where the model ends up and how the training speed changes, are different from usual training. Their work helps explain how big training steps affect model robustness in practice.
Open → 2611.08457v1

Cognitive tours help teams keep software understanding clear

Cognitive Tours: Making Understanding a Deliverable in AI-Assisted Development

Abstract: Generative AI and agentic coding are accelerating software development, leading to concerns about technical debt. But two less visible forms of debt, cognitive debt and intent debt, are emerging as key risks to software health. Cognitive debt is the absence or erosion of a team's shared understanding where no one can confidently explain how a system works or predict the impact of a change. Intent debt is the lack of clearly articulated goals, constraints, and rationale that explain what the system is for and guide how it should evolve. This paper presents Cognitive Tours, a tool designed to mitigate and repair cognitive and intent debt. Cognitive Tours is a web-based prototype for creating and following curated paths connecting user needs, design decisions, code, tests, and open questions. AI-assisted skills help audit existing waypoints and tours for possible problems or staleness and suggest candidates for new ones; humans decide what matters, verify relationships, and construct the narrative. This division of work deliberately preserves productive friction: the sensemaking involved in selecting, explaining, and revising a tour, which is intended to foster and share understanding. Our demonstration uses a tour of Cognitive Tours itself to introduce the tool and illustrate its design decisions and interaction mechanisms. A proposed evaluation agenda concludes the paper. A demo is available at https://cognitive-tours-demo.vercel.app/

Thu 5 NovSoftware Engineering
The gist
Software projects can become hard to understand over time, even if the code is fine. The authors identify two problems: cognitive debt, where no one on the team fully understands the system, and intent debt, where the goals and reasons behind the software aren’t clear. They created a tool called Cognitive Tours that helps teams document and link together user needs, design choices, and code in a way that AI can assist with but humans guide. This tool helps teams share knowledge and maintain clarity about how and why software works.
Open → 2611.08456v1

Sharp bounds on point discrepancy advance online sampling methods

Tusnády's problem and online two-sample thinning

Abstract: We determine the sharp order of discrepancy in Tusnády's problem in every fixed dimension $d\ge 2$. The largest combinatorial discrepancy of $N$ points in $\mathbb{R}^d$ with respect to axis-parallel boxes is $Θ_d((\log N)^{d-1/2})$, extending Wei's planar result and matching Nikolov's upper bound. More strongly, with high probability, this lower bound holds simultaneously for every subset obtained by deleting at most a sufficiently small fixed fraction of a uniform $N$-point sample. We apply this geometric estimate to online thinning of two independent samples of size $n$ from an unknown common distribution, where observations must be kept or discarded upon arrival. For every fixed dimension $k\ge 1$ and expected deletion budget $ρn$, with $0<ρ<2$, we prove that the minimax expected prefix discrepancy over lower orthants is $Θ_{k,ρ}((\log n)^{k+1/2})$. In dimension one, the optimal terminal discrepancy is instead $Θ_ρ((\log\log n)^{3/2})$, giving a sharp separation between the prefix and terminal objectives. For $k\ge 2$, we obtain terminal bounds differing by a factor of $\log n$. The lower bounds are based on Gaussian small-ball estimates for box-incidence matrices, while the upper bounds use stationary Metropolis thinning and, in one dimension, a terminal cancellation procedure.

Thu 5 NovData Structures and Algorithms
The gist
This paper deals with measuring how unevenly points are spread in space, a problem important for statistics and computer science. The authors find exact rates for how this unevenness grows with more points, solving a longstanding question for multiple dimensions. They then apply these findings to improve ways to choose or discard points from two random groups as data arrives, optimizing how balanced these groups remain over time. The results show different behaviors depending on dimension and how many points can be discarded. They use advanced math tools involving probabilities and random processes to prove their results.
Open → 2611.08455v1

On policy distillation can cut training compute by up to 50 times

Unpacking the Compute Efficiency of Strong-to-Weak OPD against GRPO

Abstract: On-policy distillation (OPD) trains a student on its own rollouts under a frozen teacher's per-token supervision. Does this dense signal reduce the training FLOPs needed to reach a target accuracy compared with reinforcement learning? We systematically compare vanilla reverse-KL OPD with Group Relative Policy Optimization (GRPO) across task difficulty, student and teacher size, domain, and optimization choices, measuring held-out accuracy against training FLOPs. With an external post-trained teacher, OPD generally loses to GRPO in accuracy per training FLOP at matched settings, even when the teacher is further trained with GRPO, and often suffers response-length inflation. Yet a different teacher changes the picture: when the teacher is the student's own GRPO checkpoint, OPD recovers that checkpoint's accuracy on math with $50\times$ fewer distillation FLOPs than GRPO needs to reach the same accuracy. Following the same teacher setting, we consistently observe this high efficiency with a larger student, on code, and in a second model family. On a single domain, however, the GRPO checkpoint is already the desired model, so distilling it adds to total compute. Across domains, separate GRPO checkpoints hold different capabilities, and no single checkpoint serves every domain. Multi-teacher OPD (DeepSeek-AI, 2026) consolidates per-domain GRPO experts into a single student that matches each expert's accuracy, with the distillation stage costing only 5.2% (on 2 domains) and 8.0% (on 4 domains) of the specialist training FLOPs. Counting specialist training and distillation together, this pipeline reaches joint GRPO's performance on the 2-domain mix with 42.0% fewer total FLOPs.

Thu 5 NovMachine LearningComputation and Language
The gist
Training AI models involves teaching a smaller 'student' model by copying a bigger 'teacher' model. This copying process usually needs a lot of computing power. The authors compare two training methods and find that if the teacher is the student's own checkpoint, copying can reach the same skill but with up to 50 times less compute. They also show that using multiple teachers lets one student learn from many experts efficiently, saving lots of total training work.
Open → 2611.08453v1

Refined reproducibility tools improve success in machine learning experiments

ReproBridge: Building Reproducibility into ML Research Artifacts

Abstract: Reproducing machine learning experiments requires reconstructing procedures from information scattered across papers, released code, and supporting artifacts. For coding agents, reproduction success can therefore depend on their ability to fill in missing details, rather than on the released artifacts alone. We ask whether preserving recovered procedures and decisions improves subsequent independent reproduction. We define a standardized artifact design comprising a refined codebase, environment setup, experiment launchers, and a reproduction guide, and introduce ReproBridge, an agent workflow for constructing these refined reproducible artifacts. ReproBridge-Bench provides 1,029 tasks from 387 experiments across 36 papers, anchored by five human-verified reference scores per task. Agents attempt tasks in fresh sessions with raw code or refined artifacts; a separate Auditor checks execution evidence. Across four evaluated models, refined artifacts raise mean reproduction success from 76.4% to 92.6% and reduce downstream API spending by 19.7% on average. The cross-model success-rate spread narrows from 21.6 to 3.9 percentage points, with all four models achieving mean success rates above 90%. Removing any component reduces success in the ablation study, with the largest losses from code and environment removal. These results suggest that preserving execution knowledge helps even models with lower raw-code success reproduce experiments more reliably and at lower API cost.

Thu 5 NovArtificial Intelligence
The gist
It can be hard to copy how machine learning experiments are done because the details are scattered in papers and code. The authors studied whether saving clear, organized instructions and setup helps others repeat the experiments more easily. They made a system called ReproBridge that builds these clear and complete experiment guides. Using these guides, different AI models reproduced experiments more accurately and with less cost. This shows that keeping good records of how experiments run helps anyone replicate them better.
Open → 2611.08452v1

VFlash speeds up visual planning for robots with more accuracy

VFlash: Fast, Accurate Visual Planning via Flash Primitive Decoding

Abstract: Models for physical AI tasks, such as robotics and autonomous driving, need not reason solely in language. They can use visual plans--points, bounding boxes, and trajectories--to represent spatial goals and anticipate motion. However, autoregressive vision-language models generate these plans one coordinate token at a time, making richer predictions increasingly costly. We introduce VFlash, a method for fast, accurate visual planning through Flash Primitive Decoding. VFlash exploits the known structure of visual primitives to predict their coordinates jointly, using a lightweight drafter that generates an entire primitive in one forward pass. The layout adapts to the primitive's type, dimensionality, and length, supporting compact boxes and long, variable-length trajectories. Crucially, spatial accuracy need not require reproducing an autoregressive model's exact token sequence. VFlash therefore trains on annotated primitives and directly accepts structurally valid predictions without target-token agreement. Across the evaluated 2D and 3D robot trajectory tasks, VFlash consistently reduces prediction errors relative to autoregressive decoding. Preliminary single-rollout measurements indicate approximately 25x faster generation for 3D point motion forecasting. A world action model conditioned on VFlash plans achieves 70.2% average success across four MolmoSpaces task suites, compared with 62.6% for the baseline.

Thu 5 NovRoboticsComputer Vision and Pattern Recognition
The gist
Robots and self-driving cars need to plan where to move by understanding visual goals, but current methods are slow because they predict one point at a time. The authors present VFlash, a technique that predicts whole shapes or paths all at once, making planning faster and more precise. It also accepts varied valid predictions instead of strict ones, improving flexibility. Tests show it reduces errors and speeds up predictions by about 25 times in 3D tasks, helping robots complete tasks more successfully.
Open → 2611.08449v1

Hidden markov model improves prediction of attacker behavior online

A Hidden Markov Preference Model for Online Prediction of Adversary Actions

Abstract: A defender anticipating an attacker needs a probability distribution over the attacker's next action from information available before that action occurs. Two structures complicate this: the attacker's behavioral regime persists and can switch within an episode, and each action combines an operation with state-dependent arguments whose feasible values change over time. We capture both with a hidden Markov model whose latent state is the active regime and whose regime-conditioned action law is defined on a feasibility-masked tree of executable actions. The same likelihood forms the next-action distribution and updates the regime belief once the action is seen, and a partially observed prefix contributes its resolved local factors. Estimation separates into convex logistic fits that Baum-Welch reuses when regimes are unlabeled. We derive a reach-weighted nodewise KL expression for regime information, a sequence-wise log-loss bound for switching regime paths, and a uniform fallback guarantee. On the CAGE 2 cyber defense benchmark the filtered latent state is worth 0.8 nats per step, and after a controller switch the loss begins to fall in three steps against ten for a recurrent baseline.

Thu 5 NovMachine Learning
The gist
Predicting what a cyber attacker will do next is tricky because attackers can change their behavior and choose actions based on what’s possible at that moment. The authors created a model that guesses the attacker’s current behavior type and predicts the next action by considering feasible options. Their method updates its guesses quickly when the attacker switches tactics and outperforms a standard model in tests. This helps defenders better prepare for likely attacks in real time.
Open → 2611.08445v1

Classical simulation of noisy boson and fermion sampling runs in polynomial time

Polynomial-time classical simulation of boson and fermion sampling under thermal loss

Abstract: Sampling experiments are a leading approach to demonstrating quantum computational advantage, yet their robustness to experimental noise is not completely understood. We develop a common framework for classical simulation of boson and fermion sampling under thermal loss, including pure loss. For Fock-state boson sampling, Gaussian boson sampling with fixed uniform squeezing, and fermion sampling with magic inputs, we obtain polynomial-time sampling at inverse-polynomial total variation error, for any fixed nonzero overall loss rate, and with high probability over Haar-random interferometers. A milder flatness assumption on the ideal output distribution suffices for quasipolynomial-time simulation without Haar randomness. With constant thermal loss per layer, the same flatness assumption gives polynomial-time simulation at logarithmic depth. Our bounds for Fock-state boson sampling cover both dilute and saturated regimes and become stronger near full input filling: when only a bounded number of input modes are empty, the noisy output for Haar-random interferometers converges, as the number of modes grows, to a distribution independent of the interferometer.

Thu 5 NovComputational Complexity
The gist
Quantum experiments using bosons and fermions aim to show computers doing tasks faster than classical ones, but noise can make these experiments less reliable. The authors found ways to simulate these noisy experiments efficiently on classical computers when there is some loss of particles or thermal noise. Their methods work under common conditions like random setups and varying amounts of noise, showing that noise can simplify the simulation challenge. This helps clarify when quantum advantage remains and when classical computers can keep up.
Open → 2611.08444v1

Souffleur helps resume mobile voice chats with glanceable phrases

Souffleur: A Glanceable Display for Mobile Voice Conversations

Abstract: The speech capabilities of mobile devices have grown, but their displays still rely on a text-based chat. When resuming a voice chat after a context switch, the last messages may not convey the key points of the conversation. Autobiographical use and sessions with external participants led to design goals for a mobile-first, speech-driven, glanceable display that helps users continue their reasoning from where they left off. We implement these goals in Souffleur and evaluate it in a between-subjects study with 48 participants. Compared with a conventional chat transcript, we found no reliable difference in how easily participants followed and resumed short voice conversations, nor in effort, attention or recall, although Souffleur reduces the conversation to a few short phrases.

Thu 5 NovHuman-Computer Interaction
The gist
Mobile devices let people talk by voice, but when switching back to a conversation, reading the last messages doesn’t always show the most important parts. The authors made Souffleur, a display that shows just a few short phrases to help users quickly understand and continue the conversation. They tested it with 48 people to see if it helped more than a regular chat transcript. The study found that Souffleur didn’t make it easier or harder to follow or remember the talk, but it showed much less text at a glance.
Open → 2611.08443v1

Post quantum cryptography integration in software faces lifecycle gaps

SoK: Post-Quantum Cryptography (PQC) Integration in Software Development: Approaches, Gaps, and Future Directions

Abstract: Standardised post-quantum cryptography (PQC) is critical for protecting software systems against future quantum threats, but standardised algorithms alone do not provide a pathway for their secure integration into software. This paper presents a Systematisation of Knowledge (SoK) of PQC integration in software development, synthesising existing approaches across implementation, migration, and developer education. We analyse these approaches against NIST PQC standards and PQC migration guidance, software development lifecycle coverage, cybersecurity practices, deployment maturity, and testing and evaluation evidence. Our analysis shows that existing work establishes important technical and organisational foundations but provides disconnected support across the software development lifecycle, with limited coordination between preparation, implementation, migration, deployment, maintenance, and developer practices. Evaluation evidence also remains concentrated in controlled or early-stage settings, providing stronger evidence of technical feasibility than operational readiness. We identify cross-cutting gaps and research directions for developing lifecycle-oriented, empirically validated approaches that connect technical, developer, and organisational requirements for secure PQC integration.

Thu 5 NovSoftware EngineeringCryptography and Security
The gist
Quantum computers could break current encryption, so new kinds of math-based protections called post-quantum cryptography (PQC) are being standardized. The authors review how software developers are trying to add PQC to existing programs and find that while technical progress exists, the effort is not well connected across all stages of software development. They also find the evidence mostly shows it works technically but not how ready it is for real-world use. Their work points out missing pieces and what needs to be studied next to securely add PQC into software.
Open → 2611.08442v1

Edge system predicts cyclist safety scores from handlebar cameras

Edge-Assisted Crowdsensing for Explainable Cyclist Safety Perception

Abstract: Cyclist fatality rates remain high despite policy support for active travel, and autonomous vehicles add complexity to mixed traffic. Neither crash statistics nor multi-model detection pipelines scale to continuous monitoring of perceived safety along a route. We present an edge-assisted crowdsensing system: handlebar cameras supply street-level frames, a vision-language model (VLM) turns each frame into structured traffic attributes through a single prompt, and an explainable boosting machine (EBM) combines them with OpenStreetMap road infrastructure and on-bike kinematics to predict a crowdsourced 1-9 safety score. Extraction belongs at the network edge: the fastest self-hosted model needs 2.49 s per frame and scoring takes 0.4 ms on a CPU. On 1,362 annotated frames from two London routes, the EBM regressor reaches 72.2 percent binary accuracy and a mean absolute error of 1.011 under five-fold cross-validation. It is within one accuracy point of black-box ensembles. Its per-feature shape functions give exact attribution: physical lane separation is worth +0.97 rating points, a painted lane +0.70 and a construction site -0.65. Planners can therefore price an infrastructure change in rating points, and the results enter cost-benefit analysis directly. We also report inter-annotator agreement (alpha = 0.4695), an attribute audit, and a sensitivity analysis linking attribute error to accuracy. With re-encoding, a 20 s sampling interval serves 1,000 riders at 54 Mbit/s at a cost of 1.4 accuracy points, making continuous monitoring practical.

Thu 5 NovComputer Vision and Pattern Recognition
The gist
Cycling can be dangerous, and it’s hard to continuously monitor how safe cyclists feel on their routes. The authors made a system that uses cameras mounted on bike handlebars to capture street views, and a special AI model to understand what’s in each picture. By combining this information with map data and bike movement, their system estimates how safe cyclists feel along the way. This helps city planners see which road features make cycling safer or more risky, supporting better decisions for cycling infrastructure.
Open → 2611.08441v1

Label wording changes improve accuracy for unfamiliar words in typed-decision models

Label-Wording Augmentation in a Typed-Decision Encoder: Gains on Unfamiliar Words, Not on Abbreviations or Codes

Abstract: Typed-decision models score options that the caller supplies at request time, so their accuracy depends on label wording that the model's developer does not control. We compare two releases of a 307M-parameter multilingual cross-encoder, Ru-Jev, trained on thirteen Russian-language tasks; the later release adds an augmentation that presents labels in several surface forms. Holding questions fixed and varying only how eighteen routing labels are worded, we evaluate ten label vocabularies, produced by three separate processes and checked for overlap with the training data, with five candidates per question and, for eight of them, also with eighteen. On held-out vocabularies made of ordinary or borrowed words (English-derived jargon, office slang, department names), the augmented release is more accurate in every setting, by up to 0.24. Eleven of these fourteen gains survive a Holm correction (slang with eighteen candidates and descriptive sentences with five do not), and for jargon on all labels the label-level interval excludes zero in both settings. On abbreviations and opaque codes it gives no usable gain: on abbreviations it is not better, and worse on the clean slice, and on opaque codes both releases stay at or below chance once labels related to training options are removed. In most cells where accuracy rises, the risk-coverage area falls, but with eighteen candidates confident errors rise on jargon and slang. On two datasets neither release saw, accuracy moves by -8.4 and +5.6 points. We also report four evaluation hazards from comparing the two releases.

Thu 5 NovComputation and LanguageArtificial IntelligenceMachine Learning
The gist
Some computer programs decide what to do by choosing from a list of options described by words. The authors found that changing how these option labels are written can help the program better understand unfamiliar or borrowed words, like jargon or slang. However, these word changes do not help when the options are abbreviations or codes, which the program struggles with. Their tests showed that the improved way of writing labels helped accuracy, especially when using regular words, but sometimes caused more confident mistakes with many options.
Open → 2611.08439v1

Mechanistic interpretability improves ai safety by understanding internal models

Understanding AI from the Inside: The State of Mechanistic Interpretability for AI Safety

Abstract: Neural networks are likely to be among the most consequential artefacts in human history. As these systems become more capable and autonomous, their potential to cause societal harm also grows, making AI safety one of the defining challenges of our time. Yet we continue to build increasingly powerful systems without fully understanding how they work, how they will behave in unfamiliar situations, or how to reliably control them. Mechanistic interpretability offers a path towards understanding these systems by studying their internal representations and computations, with the aim of evaluating, predicting, and controlling behaviour. We survey mechanistic interpretability for AI safety in order to answer the question: Does understanding how models work actually make them safer? We place mechanistic interpretability in the broader context of interpretability research and compare its mechanistic evidence with behavioural evaluation. We introduce the foundations of mechanistic interpretability, including features, polysemanticity, transformer computation, and circuits, and survey methods for feature extraction and analysis, circuit discovery and causal verification, explaining intermediate representations in natural language, learning dynamics, and training-data attribution. Beyond surveying existing methods, we propose a unified framework for evaluating mechanistic interpretability claims and characterise six research orientations by their goals, assumptions, and trade-offs. Finally, we examine how mechanistic understanding can support AI safety, including knowledge editing, steering, and monitoring, and assess its limitations, failure modes, open problems, and relationship to behavioural safety measures. We also release a repository of code notebooks with worked examples that reproduce key findings from surveyed methods, allowing readers to build intuition through hands-on experimentation.

Thu 5 NovComputation and LanguageArtificial IntelligenceMachine Learning
The gist
As AI systems become more powerful, understanding how they work inside can help keep them safe. The authors review ways to study a neural network’s inner computations to predict and control its behavior better. They also suggest frameworks for measuring how well these methods work and discuss how this knowledge can help steer AI safely. The paper includes practical tools for exploring these ideas through hands-on coding examples.
Open → 2611.08438v1

SM4RT improves 3D geometry and motion reconstruction from videos

SM4RT: Cascaded Feed-forward Model for 4D Reconstruction

Abstract: We introduce SM4RT, a multi-task cascade feed-forward model for dynamic scene reconstruction from RGB videos. While existing feed-forward approaches typically address geometry reconstruction and motion estimation separately--and often predict motions in a single coordinate frame that must account for camera movement--SM4RT solves these tasks sequentially by first reconstructing 3D geometry and then bootstrapping motion estimation from the predicted structure. By expressing each pixel's 3D motion in its corresponding camera frame, SM4RT reduces ambiguity arising from camera motion. To address the sparsity of real-world motion labels, SM4RT further incorporates a weakly supervised loss that regularizes unlabeled point motions using labeled point positions at the other time step. We evaluate motion estimation on three dynamic-scene datasets--Kubric, Waymo, and Point Odyssey--and SM4RT achieves the best performance on most metrics compared with prior baselines. We additionally benchmark geometry reconstruction on five dynamic scene datasets and show that SM4RT achieves competitive performance with state-of-the-art methods. Overall, our unified framework demonstrates that combining geometry reconstruction and motion estimation in a cascade not only avoids performance trade-offs but also enhances motion estimation through improved geometric reasoning.

Thu 5 NovComputer Vision and Pattern Recognition
The gist
Reconstructing moving 3D scenes from regular videos is challenging because camera motion and object movement can confuse algorithms. The authors present SM4RT, a step-by-step method that first builds the 3D shape and then estimates motion using that shape, making it easier to understand movements relative to the camera. They also use a special training strategy to handle missing motion data by relying on available position data. SM4RT performs very well on several tests involving dynamic scenes, improving motion estimation without sacrificing shape accuracy.
Open → 2611.08436v1

MedGraph improves long-term medical dialogue accuracy with graph memory

MedGraph: Maintaining Patient State with Graph Memory for Long-Term Medical Dialogue

Abstract: LLM-based medical assistants that follow a patient across visits need a memory that keeps the patient's clinical state correct as it changes. We examine the errors of five memory systems on longitudinal medical dialogue and find three recurring causes: the retrieved evidence gives an outdated state, includes another person's health facts, or lacks a safety fact the answer depends on. We present MedGraph, a graph memory built for these three cases. Construction extracts dated facts from each session, attributes each fact to the person it describes, and links medication, diagnosis, and measurement records into chains that keep earlier states. Retrieval ranks the patient's chains as units, reads each chain at the time the question asks about, and adds the original dialogue text; a patient profile lists every recorded safety fact with every question. On MedMemoryBench, MedGraph has the highest overall accuracy with both a GPT and a Qwen backbone, 10.5 and 10.4 points above the strongest of five baselines, with efficient memory construction and answering in the GPT setting.

Thu 5 NovComputation and LanguageArtificial Intelligence
The gist
Medical assistants that use large language models (LLMs) can struggle to remember updated patient information over multiple visits. The authors found that errors happen when the system uses outdated facts, confuses patients, or misses important safety details. They created MedGraph, a special memory system that organizes patient facts by date and person, linking related medical records to track changes over time. This approach helps the assistant provide more accurate, up-to-date answers about a patient's medical history.
Open → 2611.08433v1

GenAI use rises with scaffolding in ethical essay writing

Scaffolding GenAI Use in Ethical Essay Writing: A Three-Year Experience Report in Introductory Computing

Abstract: As society, ethics, and professional practice become increasingly integrated across the computer science curriculum, technical courses need practical ways to support ethical reasoning. Ethical essay assignments offer one approach, but little is known about how students use GenAI when writing such essays. This experience report examines GenAI use across three years of ethical essay assignments in a large first-year computer systems course. Across six post-essay surveys from 2024 to 2026, we analyzed 1,894 responses, linked survey data with essay grades in 2025 and 2026, and introduced a scaffolded responsible-use workflow in 2026. Under voluntary-use policies, AI adoption remained steady at around two-thirds of students, rising above 90% when use was scaffolded. Students reported mainly using AI for help with grammar and style, while tool use diversified beyond ChatGPT in 2026. Grade-linked analyses showed that AI use did not independently predict essay quality, while marker evaluations indicated high levels of critical engagement when use was scaffolded. Overall, GenAI's pedagogical value appears to depend on how assessment design guides students to evaluate and critically engage with AI-generated suggestions.

Thu 5 NovComputers and Society
The gist
Writing essays about ethics in computing can be tough for students. This paper looks at how first-year students used AI tools to help with ethical essays over three years. Through surveys and grades, the authors found that many students used AI mainly to fix grammar and style, especially when guided by a structured workflow. Importantly, using AI didn't by itself improve essay grades, but students showed more careful thinking when the AI use was supported by clear rules.
Open → 2611.08431v1

Meta access enhances chat AI control and interaction with software workspaces

The Power of Meta Access in the Software of the Future --- Demonstrated on LLM Chat UIs and Chat AI

Abstract: Chat remains the default surface for many large language model (LLM) tasks, even as agentic tools such as OpenCode excel at coding and automation. Yet the model sees the current dialogue but not the workspace around it. We explore meta access---giving the assistant a structured, permissioned view of the interface itself and propose a ladder of levels: feature tutoring; metadata, settings, and preference access; retrieval over summaries and messages, confirmed mutation, and full orchestration. Meta access can turn a chat client from many screens into one entry point for finding, navigating, organising, and operating it, while raising risks around grounding, privacy, prompt injection, and trust. General-purpose agentic harnesses are runtimes; because they can change their own settings, meta access becomes reflexive and needs a separate control-plane boundary. We ground this in the Meta Chat prototype of the Chat AI client. It builds bounded context from, e.g., summaries, settings, and relevant messages; links references to conversations, topics, and personas; supports confirmed, reversible changes; offers a browsable tutorial library; and recommends personas as user-started conversations. By exposing application state in structured form, meta access can extend screen readers from widget descriptions to semantic workspace operations. Meta access thus turns chat from a window onto one conversation into a control layer for the whole workspace, extending chat toward agentic capability without surrendering user control. As assistants become embedded in IDEs, dashboards, office suites, and operating systems, AI-era interfaces should expose a structured, permissioned model of their state and capabilities, ideally by opening their existing metamodels through a debugger-like interface.

Thu 5 NovArtificial Intelligence
The gist
Many chat-based AI tools only see the conversation but not the environment around it, limiting their usefulness. The authors propose giving AI assistants permissioned, structured access to software interfaces, allowing them to better navigate, organize, and operate tasks within an application. They built a prototype that shows how such meta access can make AI chat clients more powerful while ensuring users stay in control. This approach also helps screen readers work better and suggests how future software can open up their internal states for AI interaction safely. However, it raises challenges around privacy and trust.
Open → 2611.08428v1

Compressed dynamic models ensure realistic system estimations and control

Dynamics Aware Past-Future Information Bottleneck

Abstract: The simplification of complex dynamical systems is essential for efficient estimation and control. A principled approach to this task is through the lens of information-theoretic compression. The Past-Future Information Bottleneck (PF-IB) provides a theoretical framework for compressing linear dynamical systems. However, the standard formulation often lacks structural consistency, yielding representations that are not realizable as dynamical systems. By constraining the objective to a specific manifold of block Hankel matrices, which we prove is a Lie group, we bridge the gap between PF-IB and realization theory. Our approach ensures that the resulting compressed dynamics are realizable, thereby enabling its direct application to estimation and control. We demonstrate our approach in numerical simulations.

Thu 5 NovInformation Theory
The gist
Complex systems that change over time can be hard to understand and control. The authors study a way to simplify these systems by keeping only the most important information about their past and future behaviors. They improve existing methods to guarantee that the simplified model still behaves like a real, physical system. This makes the simplified models more useful for tasks like estimating what’s happening now and controlling the system’s future actions. They tested their method using simulations to show it works.
Open → 2611.08426v1

Vision language action models get better at spotting and classifying failures early

Failure Prediction and Classification in Vision-Language-Action Models Via Calibrated Latent Probing

Abstract: Vision-Language-Action models (VLAs) enable general-purpose embodied intelligence, but their performance is brittle under distribution shift, where unanticipated failures can damage equipment or endanger people. Deploying VLAs in real-world systems therefore requires a runtime monitor that is timely, calibrated, and informative while being efficient enough to run on the edge. Existing methods fail to fulfill these requirements. We present VLA-Tug, a lightweight probe over the latent layers of a VLA backbone that improves early failure detection and bounds the missed-detection and false-alarm rates, with minimal inference overhead. We show that supervising on the pre-failure segment of a trajectory increases early failure detection at matched false-positive rates by up to 30% over the strongest learned baseline. Under shift to unseen tasks, the bounds on missed-detection and false-alarm rates remain valid in up to 86% of runs, versus at most 21% for baselines. Unlike existing methods, VLA-Tug predicts the failure mode to enable corrective actions, raising top-3 accuracy on unseen tasks by up to 44% over a majority baseline. VLA-Tug enables real-time monitoring where the well-timed and informative probe supports lightweight steering that improves task success. We release a dataset of 3,180 annotated manipulation episodes to support future work on latent failure detection in VLAs at https://vla-tug.github.io.

Thu 5 NovRoboticsArtificial Intelligence
The gist
Vision-Language-Action models help robots and AI systems do tasks using images and language. But when these models encounter new situations, they can fail in dangerous or costly ways. The authors created a tool called VLA-Tug that watches these models from inside and can spot problems early with few mistakes. It also tells what type of failure is happening, so the system can try to fix it. This method works faster and more reliably than previous tools, even on new tasks.
Open → 2611.08425v1

Method finds continuous symmetries directly from differential data

Data-driven discovery of intrinsic Lie point symmetries of differential equation systems

Abstract: Discovering continuous symmetries directly from differential-equation data can reveal geometric structure for model reduction and scientific machine learning without symbolic determining equations or a closed-form representation of the governing system. We formulate intrinsic Lie point-symmetry discovery as an operator-theoretic problem on sampled jet-space data. Admissible generators are identified from a sampled determining operator and separated from redundant, solution-dependent, and geometrically trivial directions. The framework combines prolongation, sequential subspace restrictions, and a fixed nonlinear dictionary linear in trainable coefficients. A rank-stabilization preflight test diagnoses systems whose represented intrinsic symmetry algebra does not stabilize under dictionary refinement. On a controlled differential-equation benchmark with an analytically known 11-dimensional represented intrinsic symmetry algebra, the method recovers the complete represented generator set, reproduces its Lie-bracket structure to numerical precision, and approximates a known generator beyond the training domain. Here we show that explicit intrinsic continuous-symmetry generators can be recovered from data obtained from exact or approximate differential systems.

Thu 5 NovMachine Learning
The gist
Finding hidden symmetries in equations that describe systems can help simplify and better understand those systems. This paper introduces a method that discovers such symmetries directly from sampled data without needing the exact formulas. The authors test their approach on a known benchmark and recover all expected symmetries and their relationships accurately. This means the method can reveal important geometric features of systems just from data.
Open → 2611.08421v1

Molecular representations for drug design have major limitations

On the limitations of molecular representations

Abstract: Molecular representations such as fingerprints and learned embeddings play a central role in cheminformatics and small-molecule machine learning. They serve as the primary input for a diverse array of tasks, including clustering, dataset splitting, and virtual screening, yet their evaluation is often limited to downstream model performance on narrow benchmark tasks. We carried out a systematic investigation of the quality of molecular representations, finding that none of the state-of-the-art molecular embedding models capture graph structure, 3D shape, or ADMET endpoint similarity better than fingerprints or physicochemical descriptors. However, classical fingerprints also revealed their own material limitations. For example, we show that depending on the representation, between 225M and $\sim$4B molecules have non-unique representations in the 10.8B Enamine REAL database, with implications for virtual screening. Our findings provide an insight into the current limitations of molecular representations, outlining future research directions for the development of more robust encodings of small molecules.

Thu 5 NovMachine Learning
The gist
Molecular representations are how computers understand the features of small molecules for tasks like drug discovery. The authors found that modern machine-learned ways of representing molecules don’t capture important details like their 3D shape or how they behave in the body any better than traditional methods. However, these traditional methods also fail to uniquely identify billions of molecules, which can be a problem in large chemical databases. This study shows the current representations have significant weaknesses and suggests new approaches are needed for better molecular encoding.
Open → 2611.08420v1

Continuous maintenance improves reliability of coding benchmarks for ai models

Benchmarks as Software: Terminal-Bench and the Case for Continuous Benchmarks

Abstract: Coding agents are among the most economically consequential deployments of LLMs to date, making reliable evaluation increasingly important. Yet even benchmarks that are carefully validated at release can become stale. As models improve, they can discover valid solutions that existing verifiers reject, while changes to evaluation infrastructure can invalidate assumptions embedded in tasks and tests. We call the resulting accumulation of defects benchmark maintenance debt: a growing gap between benchmark scores and the capabilities they are intended to measure. We introduce a continuous-validation workflow for agentic benchmarks that combines community reports, task artifacts, agent traces, automated oracle checks, and human-gated repairs. We apply this workflow to Terminal-Bench 2.0, a benchmark that underwent extensive human and LM-assisted review and red-teaming before release. Our audit identifies issues in roughly 30% of the benchmark, and we release the resulting repairs as Terminal-Bench 2.1. These repairs change evaluation results: accuracy increased by over 10 percentage points and leaderboard positions move by up to three ranks, even as the overall ranking remains highly correlated (Spearman rho = 0.958). We evaluate how resource allocation shapes benchmark conclusions. We show that fixed wall-clock can materially change agent performance: For example, extending the time limit closes a 20pp harness gap on GPT 5.4 and shrinks a 30 pp gap on GPT 5.4 mini to 5 pp. Benchmark maintenance is therefore not only about repairing task artifacts: resource budgets are part of the measurement specification and must be validated alongside the tasks themselves. More broadly, benchmark maintenance debt is not just accumulated implementation bugs: our results show that as models improve, both evaluation assumptions and resource settings may need to be revalidated.

Thu 5 NovArtificial Intelligence
The gist
Benchmarks measure how well AI coding agents perform, but over time, these tests can become outdated or flawed as models get better. The authors show that frequent checking and fixing of these tests, including adjusting resource limits, helps keep benchmark results accurate and meaningful. They applied this to a coding benchmark called Terminal-Bench, fixing many issues and showing how performance rankings can change as a result. Their work highlights that benchmark upkeep involves more than bug fixes—it also means rechecking assumptions and timing rules.
Open → 2611.08417v1

New method speeds up low-temperature sampling in complex systems

Low-Temperature Sampling via Equilibrium Disagreements

Abstract: We develop a new framework for sampling at low temperatures using Glauber dynamics. In this regime, the coexistence of competing modes (commonly referred to as phases) creates bottlenecks that can make worst-case mixing exponentially slow. The main new ingredient in our framework is to relate convergence within a phase to the geometry of disagreements between two independent configurations drawn from that phase. As applications of our approach, we consider three canonical models on random regular graphs that have been central to low-temperature sampling, and establish fast convergence from natural initialisations of Glauber dynamics for every fixed degree. We show: --- For the hard-core model on random bipartite $d$-regular graphs, Glauber dynamics initialised from either one-sided independent set mixes within the corresponding phase in $n^{3/2+o(1)}$ steps throughout the non-uniqueness regime $λ>λ_c(d)$. --- For the random-cluster model on random $d$-regular graphs, for every real $q>2$, Glauber dynamics initialised from the all-in edge set mixes within the ordered phase in $n^{3/2+o(1)}$ steps for all $β\geq β_c$. Similarly, Glauber dynamics initialised from the all-out edge set mixes within the disordered phase in $n^{3/2+o(1)}$ steps for $β\leq β_c$. --- For the ferromagnetic Ising model on random $d$-regular graphs, Glauber dynamics initialised from all-plus or all-minus mixes within the corresponding phase in $n^{3/2+o(1)}$ steps throughout the low-temperature regime $β>β_c(d)$. We also give an $n^{2+o(1)}$-time algorithm that combines phase samples into samples from the full distribution, avoiding in particular time-costly approximations of the corresponding partition functions to the target sampling accuracy.

Thu 5 NovDiscrete MathematicsData Structures and Algorithms
The gist
Sampling complex systems at low temperatures can be very slow because the system can get stuck between multiple stable states or 'phases.' The authors develop a new way to understand and speed up this sampling by looking at how two independent samples from the same phase disagree. They apply this approach to several important models on random graphs and show that starting from certain natural configurations, the sampling process mixes quickly within each phase. They also provide a faster algorithm to combine these phase samples into samples representing the full system.
Open → 2611.08416v1