Precompute and reuse. I keep coming back to this idea, and there’s a 4 a.m. slide-making story behind it. Back at ICLR 2023 in Kigali, Rwanda, a student of mine was helping organize the Reincarnating Reinforcement Learning workshop. A speaker couldn’t make it, and they asked whether I could give a talk. I said yes of course, it was my student’s workshop! So I found myself making slides at 4 a.m. in my hotel room for the talk the next day. 😂 My talk was “Adaptable Reinforcement Learning in an Ever-Changing World: Reuse to Learn and Adapt Efficiently.” I also joined the panel, “Challenges & Open Problems in Reusing Prior Computation.” It was absolutely a great workshop. What stayed with me was a simple question: why keep starting over when we’ve already spent so much compute learning something useful? Today, that sounds almost too obvious. Isn’t that a big part of what foundation models are about? And really, RL post-training follows the same logic: start with a pretrained model, reuse what it has learned, and build on it with RL. But back then, training a specialist RL agent from scratch for each task was still very common. That workshop helped me put words to something that has become a recurring theme in our research. Once you take reuse seriously, the interesting question becomes: what should we learn ahead of time, and what should we leave for adaptation when the actual task arrives? You can see that question across our work, just to name a few: • SMART: pretrain control representations that transfer across tasks. • DynaFLIP: learn dynamics-aware perception that different robot policies can build on. • μ₀: learn a world model from video and reuse it across robot embodiments. • FlowBank: precompute useful agentic workflows, then choose one for each query. And now, Meta²: precompute and reuse knowledge about how to improve. An agent’s harness includes the prompts, tools, memory, hooks etc around the model. Often, you only discover what needs changing once the agent is already working. A missing tool. An instruction that keeps being forgotten. A check that needs to happen repeatedly. We want the agent to adapt as those needs appear. But reasoning about every possible change from scratch is expensive, and making changes doesn’t automatically mean making progress. So we borrow a core idea from meta-learning: learn how to adapt. Offline, Meta² learns a textual Meta-Skill that guides an evolver on when and how to change the harness, including when to leave it alone. We learn this guidance by comparing runs with no evolution, runs with the current evolver, and training runs where the evolver gets privileged verifier feedback. During a new run, that learned guidance stays fixed. At checkpoints, the evolver combines it with evidence from the current run to decide whether to keep or change the harness. The underlying model stays frozen. The guidance gets reused. The actual edits depend on what happens. One result I especially like: carrying one task’s harness edits into future tasks actually hurt performance in our experiments. Knowing how to adapt transferred better than keeping the adaptations themselves. That distinction matters for RSI. A system that keeps improving needs to figure out what to preserve from experience, what to revise, and what was only useful in one particular situation. Meta² gives us one concrete piece of that: reusable guidance for improvement, paired with adaptation while the agent is still working. Longer term, I see RSI as potentially the co-evolution of models, harnesses, and the environments they learn in. Progress in each could help the others improve. For now, we’re nailing down the harness part! I’m really proud of my students and collaborators for finding an efficient and effective way to make this work. That 4 a.m. slide-making session stayed with me longer than I expected. 🧬

Try it: pip install icalens pypi.org/project/icalens/ Website: liusida.github.io/ica-lens-p… GitHub: github.com/liusida/ica-lens-… Paper: arxiv.org/abs/2606.11722

ICA Lens is open-source, lightweight, and requires no training of another sparse dictionary. 🌹 Try it yourself: pip install icalens pypi.org/project/icalens/

SAEs have become the dominant approach in mechanistic interpretability. But what if a good old statistical method from decades ago could do just as well, at a fraction of the cost? In our latest work, we revisited Independent Component Analysis (ICA) and discovered something surprising: a bug in the evaluation code of an influential early SAE paper had significantly underestimated ICA's interpretability! After correcting it, we found ICA to be remarkably competitive with SAEs. Many of my academic friends from the good old days probably remember me as the tensor decomposition and spectral methods person. So this feels a little like going back to my roots. :) Sometimes, old mathematical tools still have surprises in store! But there's another motivation behind this work that I care about even more. I've always wished mechanistic interpretability could be more actionable. Understanding what happens inside a neural network is fascinating, but what comes next? Can we use that understanding to actually intervene, steer behavior, and improve the model? With ICA Lens, we take steps in that direction, from discovering and annotating interpretable features to using them to understand new hidden states and steer model behavior. Interpretability shouldn't end with understanding. It should empower us to act. And we'd love for the community to try it! ICA Lens is open-source, lightweight, and requires no training of another sparse dictionary. 🌹 Try it yourself: pip install icalens pypi.org/project/icalens/ Curious to hear what the mechanistic interpretability community thinks!

This is timely! Building the data engine for robotics is crucial to combat the “small data” problem in physical intelligence.

Cool work!

Congratulations @canondetortugas!

Real2Sim2Real, finally done right with “neuro-symbolic representations” and a new technique we call “controlled diversification”! Introducing Dex-One2Many: from one human video in one setting to a robot that handles many configurations beyond the demonstration—different object positions, goal poses, and grasps. How did we achieve such remarkable generalization? The key is controlled diversification—generating diverse training experiences in simulation while preserving the underlying task constraints. The symbolic structure specifies what must hold at each stage; the neural policy discovers how to achieve it. Procedurally: (1) **Extract the task structure**. A vision-language model converts the demonstration into a sequence of scene graphs that capture the task’s relational structure: which object the hand should hold, what a tool should contact, and where an object needs to end up. These relationships preserve the task while leaving room for different configurations and motions. (2) **Diversify under constraints**. We use these scene graphs to generate diverse, physically valid training states across different object positions and grasps, while preserving the task-defining relationships. The graphs also provide dense rewards that guide RL at each stage. (3) **Learn through reinforcement learning**. We train the policy in these diversified simulation environments. Rather than imitating the demonstrated trajectory, the robot discovers different ways to accomplish the same task. This is how one demonstration becomes a starting point for learning many ways to accomplish the same task. Across five manipulation and tool-use tasks, the learned policies transfer zero-shot to a real dexterous hand, achieving 75% mean success on configurations not shown in the demonstration, compared with just 4% for the next-best baseline—with no real-world fine-tuning. A wonderful collaboration with @jusukle, @JayLEE_0301, @jbhuang0604, and the entire team! Project: dex-one2many.github.io/ Paper: arxiv.org/abs/2610.12470 #Robotics #NeuroSymbolicAI #ReinforcementLearning #DexterousManipulation

Real2Sim2Real, finally done right with neuro-symbolic representations! Introducing Dex-One2Many: from one human video in one setting to a robot that generalizes to configurations beyond the demonstration—different object positions, goal poses, and grasps. The key to the remarkable generalization is the abstraction. Dex-One2Many extracts the task’s relational structure into “scene graphs”, then uses them to generate diverse training states and rewards for RL in simulation. The graphs specify what must hold at each stage (constraints, our inductive bias); RL discovers how to achieve it across different configurations. One demonstration opens up many ways to accomplish the same task—and the learned policy transfers zero-shot to a real dexterous hand. Project: dex-one2many.github.io⁠