DSSP: Diffusion State Space Policy with Full-History Encoding
summary
The gist
Diffusion-based imitation learning has shown strong promise for robot manipulation However, most existing policies condition only on the current observation or a short window of recent observations…
In short
Diffusion-based imitation learning policies often fail long-horizon tasks because they only consider recent observations. DSSP introduces a history-conditioned diffusion policy that uses a state space model to efficiently encode the entire observation history into a compact context. This allows the robot to resolve ambiguities and track task progress over long sequences, leading to superior performance in real-world manipulation.
Key concepts
- History Encoder
- This component compresses the entire sequence of past observations into a small context representation. It uses a causal state-space model with Mamba architecture to selectively filter out redundant data while keeping critical, task-relevant events that predict future states.
- Dynamics-Aware Auxiliary Objective
- This training objective is added to the history encoder. It forces the compressed context representation to retain information useful for predicting the next state given an action. This ensures the history captures cues about how actions affect future states, not just what happened previously.
- Hierarchical Conditioning Mechanism
- The policy combines long-term task progress (from the history encoder) with recent local observations. It does this by prepending a causal prefix to the noisy action sequence, allowing the diffusion backbone to process both historical context and immediate state information simultaneously for better decisions.
- Timestep Decoupled Conditioning
- The method uses Adaptive Layer Normalization (AdaLN) to inject timestep modulation independently into the action tokens. This keeps the history context stable during denoising, ensuring that the diffusion process correctly balances long-term memory with immediate action details.
Terminology used across episodes
This episode discusses
- DSSP: Diffusion State Space Policy with Full-History Encoding · Paper Radio
- Openpi Comet: Competition Solution For 2025 BEHAVIOR Challenge
- RT-2: Vision-Language-Action Models Transfer Web Knowledge to Robotic Control
- Mamba Policy: Towards Efficient 3D Diffusion Policy with Hybrid Selective State Models
- GAF: Gaussian Action Field as a 4D Representation for Dynamic World Modeling in Robotic Manipulation
- History-Aware Visuomotor Policy Learning via Point Tracking
- RoboTwin 2.0: A Scalable Data Generator and Benchmark with Strong Domain Randomization for Robust Bimanual Robotic Manipulation
- Diffusion Policy: Visuomotor Policy Learning via Action Diffusion
- Transformers are SSMs: Generalized Models and Efficient Algorithms Through Structured State Space Duality
- Dream2Flow: Bridging Video Generation and Open-World Manipulation with 3D Object Flow
- Learning Video Generation for Robotic Manipulation with Collaborative Trajectory Control
- VITA: Vision-to-Action Flow Matching Policy
- Mamba: Linear-Time Sequence Modeling with Selective State Spaces
- SeedPolicy: Horizon Scaling via Self-Evolving Diffusion Policy for Robot Manipulation
- FlowDreamer: A RGB-D World Model with Flow-based Motion Representations for Robot Manipulation
- Causal Confusion in Imitation Learning
- Denoising Diffusion Probabilistic Models
- AdaFlow: Imitation Learning with Variance-Adaptive Flow-Based Policies
- GraphCoT-VLA: A 3D Spatial-Aware Reasoning Vision-Language-Action Model for Robotic Manipulation with Ambiguous Instructions
- ContextVLA: Vision-Language-Action Model with Amortized Multi-Frame Context
- MaIL: Improving Imitation Learning with Mamba
The paper
DSSP: Diffusion State Space Policy with Full-History Encoding · Read on arXiv
Zhiyuan Guan, Jianshu Hu, Han Fang, Yunpeng Jiang, Yize Huang, Shujia Li, Xiao Li, Yutong Ban
Shanghai Jiao Tong University
Transcript
Introduction to the show: ident: Robotics Radio. Generated commentary on the latest robotics and control papers.
Rosa: We're looking at the paper: "DSSP: Diffusion State Space Policy with Full-History Encoding".
Dev: Here's the gist of the paper. Diffusion-based imitation learning has shown strong promise for robot manipulation However, most existing policies condition only on the current observation or a short window of recent observations, limiting their ability to resolve historydependent ambiguities in long-horizon tasks.
Rosa: The proposed DSSP enables efficient, full-history conditioning for robot manipulation.
Dev: Core Methodology The method introduces DSSP, a history-conditioned Diffusion State Space Policy that leverages the continuous sequence modeling properties of State Space Models (SSMs) to achieve efficient, full-history conditioning for robot manipulation.
Rosa: The history encoder effectively compresses the entire observation stream into a compact context representation.
Title and authors: Rosa: So we're looking at this paper called "DSSP: Diffusion State Space Policy with Full-History Encoding" and the authors are Zhiyuan Guan, Jianshu Hu, Han Fang, Yunpeng Jiang, Yize Huang, Shujia Li, Xiao Li and Yutong Ban. What's the big idea here in simple terms?
Dev: Well it’s trying to fix a problem with how we train these diffusion based imitation learning policies for robots. Right now most of them only look at what’s happening right now or maybe just a few recent frames, which makes it really hard for the robot to figure out what happened earlier in a long task.
Taro: So, if you're trying to do something that takes a long time to finish, like building something complex with many steps, and the robot gets confused because it can't remember the whole history, that’s where this paper steps in.
Rosa: Exactly. The paper introduces DSSP which is a diffusion state space policy that can condition itself on the entire history of observations efficiently. They use State Space Models to compress all those past observations into one compact context representation so we don't have to deal with every single past frame directly.
Dev: And they don't just dump that context in there, they optimize the encoder with a special training objective called a dynamics aware auxiliary training objective. That’s important because it makes sure this compressed memory actually keeps the information needed for predicting future states useful for action generation > <ref:2605.14598#pg1>
Taro: So, if that auxiliary objective is working right, it means the context we’re creating isn't just a jumble of pixels or sensor readings; it’s capturing the things that actually matter for where the robot is going next > <ref:2605.14598#pg1>
Rosa: And then they fuse this high level context representation with the most recent state observations to create a hierarchical conditioning mechanism for generating actions. It’s like having both a long-term memory and a very fresh look at what's happening right now > <ref:2605.14598#pg1>
Dev: That sounds like they are building two layers of information for the policy to use when it makes a decision, which is smart because it separates the long term progress from the immediate local cues > <ref:2605.14598#pg2>
Taro: But I wonder about those memory and inference costs they mention on page two. They seem to admit that storing the full history context might introduce more memory usage or even some redundant visual inputs if not handled carefully > <ref:2605.14598#pg2>
Title and authors: Rosa: That’s a fair point, Taro. The authors actually look at this issue and they explore ways to make it more compact, looking at things like keyframes or visual traces instead of the full history > <ref:2605.14598#pg2>
Dev: But the core idea here is that even with the full history context, they want to keep it as efficient as possible so we can actually run these policies in real time, which is a major engineering hurdle > <ref:2605.14598#pg1>
Taro: And I see how their approach addresses the ambiguity issues that happen in long horizon tasks when you only have short windows, like when you're trying to track a specific sequence of events > <ref:2605.14598#pg3>
Rosa: That’s what they are targeting. They showed that history acts as a sufficient statistic for the belief state, which lets the policy disambiguate different situations based on what happened before > <ref:2605.14598#pg3>
Dev: So, when we look at their theoretical results on page four, they establish two main propositions. First one says that the minimum imitation loss for a history-conditioned policy is always less than or equal to that of a reactive policy > <ref:2605.14598#pg4>
Taro: And the second proposition seems to be about when things get really messy, specifically in situations where there's observation aliasing, they prove that history conditioning strictly reduces the minimum imitation loss compared to a reactive policy as long as some mathematical condition holds > <ref:2605.14598#pg4>
Rosa: So theoretically, it suggests that just having access to the full history isn't just nice for debugging; it actually provides a tangible performance benefit over simpler methods in many scenarios > <ref:2605.14598#pg4>
Dev: Experimentally, the results are pretty compelling. On RoboTwin, DSSP showed a twelve point eight percent relative improvement compared to DP3 on average, with twenty one point four percent on long horizon tasks > <ref:2605.14598#pg2>
Taro: And in the real world tests too, they saw a substantial jump in success rates for things like Morse Tapping, going from thirty percent up to seventy percent across all tasks > <ref:2605.14598#pg2>
Rosa: That improvement on Morse Tapping is interesting because it shows it’s better at tracking the actual progress of the task, not just reacting to the last few frames > <ref:2605.14598#pg2>
Dev: For real time systems, I’m focused on how they handle those long sequences during inference. They decouple the timestep modulation and inject it independently through adaptive layer normalization called AdaLN into the action tokens > <ref:2605.14598#pg3>
Taro: So that means the context representation stays stable even while the diffusion process is running, which prevents that from becoming too noisy or unstable during the generation steps > <ref:2605.14598#pg3>
Title and authors: Rosa: It seems like this combination—the history encoder, the dynamics objective, and that hierarchical conditioning—is what allows them to get such good performance while keeping the model size relatively small compared to other complex methods > <ref:2605.14598#pg2>
Dev: That efficiency is a big deal because we need policies that are deployable on actual hardware, not just running on a powerful server for research purposes > <ref:2605.14598#pg3>
Taro: And I still see the caveat mentioned in page two about potential redundant visual inputs or spurious correlations if you don't manage the context memory right > <ref:2605.14598#pg2>
Rosa: That’s the trade-off they are acknowledging, which is that capturing all that history isn't free; it requires careful design to make sure we only keep the relevant, task-relevant events > <ref:2605.14598#pg1>
Dev: So to wrap up this paper "DSSP: Diffusion State Space Policy with Full-History Encoding", it shows that full history conditioning significantly improves temporal disambiguation and task progress tracking in history sensitive tasks > <ref:2605.14598#pg3>
Taro: It confirms that capturing action relevant mutual information from the entire observation stream is a sufficient way to resolve those latent environmental configurations > <ref:2605.14598#pg3>
Rosa: We get to see how they integrate long horizon context with recent local observations through that hierarchical prefix conditioning, which really ties everything together for action generation > <ref:2605.14598#pg3>
Dev: It’s a solid piece of work because it shows that the structure of the State Space Model can be leveraged effectively for this kind of complex sequential reasoning > <ref:2605.14598#pg1>
Taro: I think the real world success, like in Object Swap where they used history to infer previous movement direction, is what really makes this paper interesting for practical robotics applications > <ref:2605.14598#pg2>
Rosa: Exactly. So we've seen how they use a history encoder with Mamba to filter observations and then feed that into a diffusion backbone that’s stabilized by AdaLN, which leads to state of the art results with smaller models > <ref:2605.14598#pg2>
Dev: It's an interesting blend of deep learning sequence modeling and reinforcement learning structures, showing how they can be combined without immediately hitting massive computational walls > <ref:2605.14598#pg3>
Taro: The main thing I take away is that for memory dependent tasks, the history isn't just data; it’s a crucial piece of information that lets the robot know where it is in the overall plan > <ref:2605.14598#pg2>
Rosa: It’s definitely something to watch as we push these policies out into more complex, real world manipulation scenarios > <ref:2605.14598#pg1>
The paper's summary: Rosa: So, to wrap up what we just heard about this DSSP paper, the main idea is that they’ve taken diffusion models and put a special history encoder on top of them to let the robot actually remember everything that happened before.
Dev: Right. It’s not just feeding it the last few frames; they are compressing the entire observation stream into one compact context representation using a State Space Model, which is pretty clever for managing memory.
Taro: And that compression isn't just dumping data; they trained this encoder with a dynamics aware objective, meaning it learns to keep only the historical events that actually matter for predicting where the robot is going next.
Rosa: Exactly. So we’re not just storing pixels; we’re storing task-relevant events that reveal progress, which solves that problem of visual aliasing in long tasks where you can't tell if you've completed a step or not.
Dev: And they combine this high level context with the very recent observations through a hierarchical mechanism, which gives the policy both the big picture and what’s happening right now for making an action.
Taro: That combination means when things get messy in real-world manipulation, like when you're trying to swap objects or perform a sequence of taps, this history conditioning actually helps it track the overall goal better.
Rosa: The results they got are pretty strong too; they showed state of the art performance with a model size that is significantly smaller than what you’d expect for this level of memory, which is huge for deployment.
Dev: And on real-world tests, they saw success rates jump from thirty percent up to seventy percent on tasks like Morse Tapping, which means it's genuinely improving how robots handle memory-dependent manipulation.
Taro: That jump in success rate really shows that the system is better at inferring the overall task progress and distinguishing between intermediate goals and actual completion.
Rosa: So what this means for us in the field is that history isn't just extra data; it acts like a sufficient statistic for the belief state, letting the policy figure out what’s going on in the environment based on its past actions.
Dev: That capability to resolve latent environmental configurations through action relevant mutual information is what really suggests this structure can be used to make much more robust planning systems.
Taro: It confirms that for memory dependent tasks, having access to the full history is a crucial piece of information that lets the robot know where it is in the overall plan.
Rosa: This paper shows how they integrate long horizon context with local observations through that hierarchical prefix conditioning, which really ties everything together for action generation.
Dev: It’s a solid piece of work because it shows that the structure of the State Space Model can be leveraged effectively for this kind of complex sequential reasoning under real-time constraints.
Taro: I think the real world success on things like Object Swap where they used history to infer previous movement direction is what really makes this paper interesting for practical robotics applications.
Rosa: It’s definitely something to watch as we push these policies out into more complex, real world manipulation scenarios.
The paper's improvements: Tom: So we've talked about what DSSP is, and now we’re looking at what they suggest to improve it further. Rosa, what’s the main thing they are suggesting for making this history conditioning even better?
Rosa: They focus on how to make that context representation more reliable. The paper talks about using a dynamics aware auxiliary training objective again, which is meant to force that memory to keep information that predicts future states instead of just looking at past pixels.
Dev: That makes sense from a control loop point. If the memory isn't predicting future states under an action, it’s just noise, and that’s a safety risk for real-time systems.
Taro: Exactly. The paper is suggesting that this dynamic objective helps prune the unnecessary history tokens, so we keep the sparse task-relevant events which are predictive of future states.
Rosa: And then they talk about how to make sure the action generation process itself is stable, even when you’re processing that whole history context, by decoupling the diffusion timestep modulation.
Dev: That decoupling through adaptive layer normalization, or AdaLN, is smart because it keeps the representation of history and local observations stable throughout the entire denoising process.
Taro: So you don't want the long memory context to suddenly get thrown off just because of a fluctuating timestep during action generation. That’s a key part of making this policy runnable in real-world scenarios.
Rosa: And they also touch on how to manage the trade-off between using the full history and keeping the model size small, implying that if you design the encoder right, you can get good performance without ballooning the hardware requirements.
Dev: It’s a big thing for deployment because most high performance models are just too slow or too big for actual robotics. They show that this hierarchical conditioning is efficient even as you increase the length of the history used.
Taro: It suggests that if we can get better at encoding what "action relevant" means, we can use more history without suffering massive computational overhead.
Rosa: So these improvements focus on making the memory smarter and ensuring the generation process remains stable under those long-horizon conditions.
Dev: What this implies for us is that to build robust robot policies, we need to think about how to structure that state space representation so it inherently understands the causal relationship between past events and future actions.
Taro: It moves beyond just reactive models by showing a structured way to integrate long-term planning context with immediate state feedback.
Rosa: This paper lays out the mechanics for achieving that, so we can start thinking about how to test these more complex memory systems outside the controlled lab environment.
Conclusion: Rosa: So we've covered how DSSP uses full history to fix memory problems in robot manipulation, and now we're heading to the final thoughts on this paper.
Dev: Yeah, essentially this is about making sure that diffusion based imitation learning policies can handle long horizon tasks by giving them a proper way to condition on all the past observations.
Taro: It’s about moving beyond just looking at what's happening right now and actually understanding the task progress over time.
Rosa: The core idea is that this history conditioning, combined with the State Space Model encoder, acts like a sufficient statistic for the belief state, which means it lets the policy figure out what's going on in the environment based on its past actions.
Dev: So if you're dealing with a control loop that needs to make decisions over many steps, this structure helps keep that representation stable and accurate.
Taro: It changes how we think about autonomy because it shows that capturing action relevant mutual information from the entire observation stream is a sufficient way to resolve those latent environmental configurations.
Rosa: The experiments showed state of the art performance with a significantly smaller model size, which is pretty good for hardware deployment, even though they still had to handle some trade-offs in context memory management.
Dev: That twelve point eight percent improvement on RoboTwin and the success rate jump on Morse Tapping show that this structure actually translates into tangible real world benefits when you need to track progress.
Taro: For tasks like Object Swap, where they had to infer previous movement direction using history, it proves that this method is better at resolving ambiguity than a simple reactive policy.
Rosa: So in the end, the DSSP paper gives us a solid framework for building more robust and temporally aware robot policies that can handle longer sequences of actions.
Dev: It’s a big step because it shows how to leverage sequence modeling structures like State Space Models in this way without immediately hitting massive computational walls on real time systems.
Taro: Moving forward, we need to see if this kind of history encoding can scale up to even more complex, persistent shared environments where memory is constantly being updated by multiple agents.
Rosa: We'll keep an eye on how researchers use this full-history conditioning as they push these policies out into more challenging and messy real world manipulation scenarios.
More episodes
- 2608.13438-ContactGuard: Pre-Contact Execution Monitoring with Action-Conditioned Latent World Models
- 2610.34593-Future Prediction as Training-Only Video Supervision for Pretrained VLA Policies
- 2610.35385-EmbodiedLab: Beyond Manipulation, Benchmarking Embodied Agents That Act to Know
- 2610.36378-Data-Driven Hamiltonian for Neural Optimal Control
- 2610.37275-A Heuristic for Scheduling Autonomous Vehicles at Intersections
- 2610.37288-Dynamic Coordination of Autonomous Vehicles at Intersections
- 2610.37632-Real-Time Coordination of Autonomous Vehicles at Intersections
- 2611.13779-Softness is something you also need! Why compliance helps control: information metrics of a passive walker with compliant ankle
- 2611.13411-Residual-Corrected Physics-Informed Neural Network KKL Observers with Input-to-State Stability Guarantees
- 2611.14488-Is Your Robot's Memory Just a Clock? Temporal Shortcuts in Memory-Augmented VLA Policies