DSSP: Diffusion State Space Policy with Full-History Encoding

arXiv:2605.14598 · cs.RO · Submitted 2026-05-14 · Read on arXiv

Listen

Radio episode about this paper

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.

Zhiyuan Guan, Jianshu Hu, Han Fang, Yunpeng Jiang, Yize Huang, Shujia Li, Xiao Li, Yutong Ban

Shanghai Jiao Tong University

cs.RO

Submitted: 2026-05-14

Updated: 2026-11-16

License: http://arxiv.org/licenses/nonexclusive-distrib/1.0/

Importance score: 95/100

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…

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

Summary

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. p. 0 The proposed DSSP enables efficient, full-history conditioning for robot manipulation. p. 0

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. The history encoder effectively compresses the entire observation stream into a compact context representation. p. 0 To ensure this context preserves critical information regarding future state evolution, the encoder is optimized with a dynamics-aware auxiliary training objective. p. 0 This high-level context representation is then seamlessly fused with recent state observations to form a hierarchical conditioning mechanism for action generation. p. 0 Furthermore, the diffusion backbone itself is instantiated using an SSM to maintain architectural consistency and minimize GPU memory overhead. p. 0

History Encoding and Context Learning

The history encoder is designed as a causal state-space history encoder that maintains a compact context representation by recurrently integrating incoming multi-modal observations. This process uses the Mamba architecture for input-dependent selective updates, allowing the encoder to filter redundant observations while preserving sparse task-relevant events. p. 4 The resulting context token serves as a compressed memory for action generation. p. 4 To ensure this representation preserves historical cues useful for future decisions, a dynamics-aware auxiliary objective is introduced, which encourages the context representation to retain action-relevant historical information by requiring it to support prediction of the next state under the executed action. p. 4

Hierarchical Conditioning Mechanism

The policy utilizes a hierarchical conditioning mechanism that integrates long-term task-progress information and recent local observations. This is achieved by constructing a causal prefix to the noisy action sequence, denoted as Ct = [ct, zt−N+1,. p. 4.., zt], where ct is the context representation produced by the history encoder and zt−N+1:t are the most recent state tokens. p. 4 This hierarchical prefix is then prepended to the noisy action sequence, and this resulting sequence is processed by an SSM denoising backbone. p. 4 The timestep modulation is decoupled and injected independently through Adaptive Layer Normalization (AdaLN) into the action tokens, keeping Ct as a stable representation of history and local observations throughout the denoising process. p. 5

Theoretical Advantages

The theoretical analysis establishes two core propositions regarding the benefits of history conditioning in imitation learning. Proposition 4. p. 5 p. 51 establishes that the minimum achievable diffusion-based imitation loss for a history-conditioned policy is always less than or equal to that of a reactive policy. p. 5 Proposition 4.2 proves that in the presence of observation aliasing, history conditioning strictly reduces the minimum achievable imitation loss compared to a reactive policy whenever IE(at; ht ot) > 0. p. 5

Experimental Performance

Extensive experiments across simulation benchmarks and real-world manipulation tasks show that DSSP achieves state-of-the-art performance with a significantly smaller model size. On RoboTwin, DSSP achieves a 12. p. 78% relative improvement compared to DP3 on average, with the largest improvement on long-horizon tasks (21. p. 74%). In real-world experiments, DSSP substantially outperforms DP3 across all tasks, increasing the average success rate from 30% to 70% (a 133. p. 83% relative improvement). p. 7

Failure Mode Analysis

The failure mode analysis reveals that for Morse Tapping, DSSP achieves the largest relative improvement on this task because it better tracks the tapping progress and executes the correct number of taps. For Put Bottles, DSSP better infers the overall task progress and distinguishes intermediate subgoals from true task completion. p. 6 For Object Swap, DSSP uses historical context to infer the previous movement direction and resolve this ambiguity. p. 0

Conclusion

In this paper, we introduce DSSP, an efficient full-history conditioned diffusion state-space policy for long-horizon robot manipulation. Our results show that compactly encoding the full observation history improves temporal disambiguation and task-progress tracking in history-sensitive tasks. p. 8 The proposed state-space history encoder, dynamics-aware objective, and hierarchical timestep-decoupled conditioning jointly integrate long-horizon context with recent observations for action generation. p. 8 The paper demonstrates that history acts as a sufficient statistic for the belief state, allowing the policy to disambiguate latent environmental configurations through the capture of action-relevant mutual information. p. 6

Green — the paper says it, and the page is printed. Red — no passage carries it, so treat that sentence as unverified. The same check runs on your own text: check a summary against its source, $5.

Improvements for AI systems

  1. Full-history context encoding allows history-conditioned diffusion policies to resolve visual aliasing, enabling consistent execution in long-horizon tasks by capturing sparse historical events that reveal task progress.

  2. The state space history encoder, instantiated with Mamba and optimized with a dynamics aware auxiliary objective, compresses the entire observation stream into a compact context representation while retaining task-relevant events predictive of future states.

  3. The hierarchical conditioning mechanism fuses learned context representations and immediate state representations via prefix conditioning to provide both long-term task progress information and recent local observation cues for action generation.

  4. Timestep decoupled action denoising, achieved through Adaptive Layer Normalization (AdaLN), ensures that the diffusion timestep modulation is injected independently into the action tokens, maintaining a stable representation of history and local observations throughout the denoising process.

  5. The system can achieve state-of-the-art performance with a significantly smaller model size while demonstrating superior efficiency of hierarchical conditioning as history length increases.

  6. In real-world applications, the policy can substantially improve success rates on memory-dependent manipulation tasks by effectively tracking task progress and resolving ambiguity caused by observation aliasing, such as in Morse Tapping or Object Swap scenarios.

Sources

Related papers