Papers for

robotic control teams

Papers whose findings have a practical use for this group, as judged from the abstract. Open a paper to read what it means in practice.

Training agents to find and follow the best joint convention

ConventionPlay: Capability-Limited Training for Robust Ad-Hoc Collaboration

Abstract: Ad-hoc collaboration often requires agents to identify and adhere to some shared convention within a cooperative task. Existing work on reinforcement learning (RL) for ad-hoc collaboration focuses on training agents that adapt to the conventions established by their partners. These methods fail to consider the possibility that while some partners might follow only a single fixed convention, others may themselves be capable of adapting to multiple conventions. Here we present ConventionPlay, an RL-based approach that teaches agents to discover their partner's optimal convention by training against a learned population of partners that exhibit different degrees of adaptability across conventions. Some of these partners follow a single, fixed convention, while others are able to adapt to a subset of the possible conventions for the task in question. The existence of partners that support a limited subset of conventions forces agents trained against this population to actively probe their partner's capabilities, and steer their partner towards the most effective joint strategy that they are capable of following. Our experimental results demonstrate that agents trained via ConventionPlay achieve superior performance to existing ad-hoc collaboration methods against test populations of partners that are compatible with multiple conventions.

Thu 8 OctMultiagent Systems
The gist
When computers or robots work together without prior coordination, they need to figure out a common way to act. This paper shows how to train such agents to guess how their partners prefer to work and adjust their behavior accordingly. By training against partners who sometimes change their style and sometimes stick to a fixed way, the agents learn to test their partner’s abilities and settle on the best joint approach. The result is agents that collaborate more effectively with a variety of partners they didn't train with.
Open → 2610.11842v1

Supervisory control backoff reduces failures in tool-using agents

When the Governor Becomes the Disturbance: Control-Generated Disturbance and Cost-Aware Backoff in Governed Tool-Using Agents

Abstract: Supervisory governors can interfere with the tool-using agents they regulate. We study this possibility in a controlled file-recovery environment where increases in regulatory intensity trigger experimentally imposed tool failures. A cost-blind governor can turn these failures into persistent blocking that prevents task completion. We compare this governor with a backoff rule that reduces intervention probability using a moving average of known induced events. On a hand-coded stochastic-policy agent, the failure pattern appears under both result replacement and execution of corrupted tool arguments. For the persistent policy, adaptive backoff improves completion relative to a fixed weak governor with approximately matched intervention frequency. A Gemini 2.5 Flash experiment comprising 576 episodes across 6 tasks also shows reduced blocking and improved completion under backoff; among the tested settings, intermediate backoff strength achieves the highest observed aggregate success. These results identify an interaction between intervention cost and persistent action blocking, together with a possible mitigation. The cost mechanisms are imposed and their induced events are directly observable to the backoff rule; applicability beyond this controlled environment remains an empirical question.

Tue 6 OctArtificial IntelligenceMultiagent Systems
The gist
Sometimes, a system that supervises robots or software tools can accidentally cause problems instead of helping. The authors studied a setup where stricter control made the tools fail more often, which then blocked tasks from finishing. They found that if the supervisor scales back how much it intervenes based on the failures it causes, the system works better and finishes tasks more successfully. This approach was tested in simulations and on hardware with positive results, though it’s unclear if it works in all situations.
Open → 2610.09037v1

Off-policy merging improves continual learning for AI models

Off-Policy Merging Beats On-Policy Self-Distillation for Continual Learning

Abstract: A long-standing goal of AI is a model that can continually learn and improve itself. On post-trained models, supervised finetuning (SFT) on new data often causes poor generalization and catastrophic forgetting. As such, the conventional wisdom is that on-policy training is a prerequisite for continual learning. In practice, however, data containing new knowledge or capabilities are often off-policy. While methods such as on-policy self-distillation (OPSD) try to bridge this gap by converting off-policy data into on-policy signal, they have been shown to cause reasoning collapse. In this paper, we show that off-policy merging beats OPSD for continual learning. We first show that SFT learns a useful signal from new data, but naively applying its update interferes with existing capabilities. We reduce this interference with a simple recipe we term grafting, which changes where the update is learned and how it is applied: (1) learning the update on an earlier donor checkpoint, ideally even before the end of pretraining, and applying the weight update to the post-trained model; (2) scaling the weight update, equivalent to a form of model merging; and (3) optionally, masking the most sensitive update directions when the new data distribution is far from the post-trained model. Across continual learning settings including (1) distilling from expert traces, (2) self-improvement with STaR and Pedagogical RL, and (3) injecting knowledge after pretraining cutoff, grafting Pareto-dominates both SFT and OPSD in new-task and old-task performance, while avoiding expensive on-policy sampling. Therefore, our work challenges on-policy training as a necessity for continual learning on RL-trained models.

Mon 5 OctMachine LearningArtificial IntelligenceComputation and Language
The gist
AI models often struggle to learn new things without forgetting old knowledge, especially when learning from data that wasn’t gathered by the model itself. The authors show that a method called off-policy merging works better than previous techniques that rely on on-policy training, which requires data generated by the model. Their approach, called grafting, involves combining updates learned from earlier versions of the model with the current version to reduce interference and forgetting. This method leads to better learning of new skills while keeping older knowledge intact.
Open → 2610.05872v1

Spiking neural network predicts future game states in reinforcement learning

Spiking Neural Network Predicting Sequence of the External Worlds States in Model-Based Reinforcement Learning

Abstract: This paper presents a spiking neural network (SNN) designed to predict the sequence of the external world states starting from the current world state. This SNN does not create the world dynamics model - instead it incorporates the SNN trained to predict the next world state and provides all mechanisms necessary to make the chain of predicted world states. These mechanisms are entirely spiking - they are implemented as spiking neuron ensembles. The present article describes this neuronal structure and tests its operation on a classic RL benchmark - ATARI ping-pong.

Wed 23 SeptNeural and Evolutionary Computing
The gist
Predicting what will happen next in a game or the real world is hard. The authors developed a brain-inspired spiking neural network that can guess the sequence of future states starting from the current one. Instead of building a full model of how the world works, this network links smaller parts that predict the next step and chains those predictions together. They tested this system on a classic video game called Atari ping-pong and showed it could predict game states over time.
Open → 2609.27459v1

Convex optimization handles changing goals and shrinking options efficiently

Convex Optimization with Nested Evolving Feasible Sets (CONES) under Time-Varying Loss Functions

Abstract: Convex Optimization with Nested Evolving Feasible Sets (CONES)} was introduced in \cite{CONESVaze} where the objective function \(f\) remains fixed but the feasible region evolves over time as a nested sequence \(S_1 \supseteq S_2 \supseteq \cdots \supseteq S_T\). The goal of an online algorithm is to simultaneously minimize the regret with respect to hindsight static optimal benchmark and the total movement cost $M_\cA(T)$ while ensuring feasibility at all times. CONES is an optimization-oriented generalization of the well-known \emph{nested convex body chasing} (NCBC). In this paper, we extend CONES to allow for loss functions $f_t'$s to also change over time. When all loss functions are convex, we show that the projected proximal algorithm achieves $O(T^{1-β}), O(T^β)$ simultaneous regret and movement cost, respectively, for any $β\in [0,1)$, over a time horizon of $T$. We also show that any {\it weakly adaptive} online algorithm with $O(T^β)$ regret has a movement cost of $Ω\left(T^{\frac{1-β}{2}}\right)$ for any $β\in [0,1)$. When all loss functions are strongly convex, we show that the projected proximal algorithm simultaneously achieves $O(1)$ regret and a movement cost of $O(\log T)$. To complement this, we show that any online algorithm with sublinear {\it anytime} regret has a movement cost of $Ω\left(\log T\right)$.

Thu 10 SeptMachine LearningData Structures and Algorithms
The gist
This paper studies how to solve optimization problems when both the rules and goals change over time. The authors extend previous work that only handled shrinking constraints to also cope with changing objectives. They show that certain algorithms can balance making good choices and not changing those choices too much over time. Their results show trade-offs between how well the algorithm performs and how much it moves, depending on the problem’s difficulty.
Open → 2609.11207v1