EIDA: Execution-Interface Dynamics Adaptation for Real-to-Sim-to-Real Robot Navigation

arXiv:2610.01219 · cs.RO · Submitted 2026-10-01 · Read on arXiv

Listen

Transcript

Introduction to the show: ident: Robotics Radio. Generated commentary on the latest robotics and control papers.

Rosa: Today's paper: "EIDA: Execution-Interface Dynamics Adaptation for Real-to-Sim-to-Real Robot Navigation".

Dev: Simulation-to-robot transfer can fail when velocity commands produce motion and feedback that differ from those modeled during policy training, leading to navigation failures in physical execution.

Rosa: First, who's behind it and why it matters.

Title and authors: Rosa: So we've looked at the basics of EIDA, and now I want us to look at what it actually does in detail regarding its core mechanics. Basically, the paper describes how EIDA fits models to capture how the real robot executes commands by fitting models to its actual performance data from the physical system, allowing us to update our simulation geometry on the fly so we can train policies more effectively without needing super detailed actuator models.

Dev: I see. It’s about learning the translation layer between what we command and what actually happens in reality, which means we don't have to waste time modeling every single motor torque curve perfectly for every new platform, which is a huge relief for the engineering side of things.

Taro: What really strikes me about this is how it handles when the real world just decides to do something unexpected; the system learns a way to predict that feedback so the policy doesn't get completely lost when execution deviates from its simulation expectations.

Rosa: Exactly, Taro, and that separation into motion prediction and velocity feedback prediction is smart because it lets us tackle those two different aspects of the execution gap distinctly. We’re not just modeling a path; we’re modeling how that path feels in physical terms through the velocity history component they've added.

Dev: That velocity history buffer you mentioned is where I get most of my concern, Rosa; if that model isn't running fast enough, or if the prediction is lagging, we introduce latency right into our control loop, and that could cause instability on a high-frequency platform.

Taro: But the paper suggests it’s about capturing execution responses rather than just control inputs because those responses are what drive the policy's decisions in the real world; if you can model that response accurately, then when things misbehave, the policy has better situational awareness of what's actually happening at that moment.

Rosa: And their results across wheeled and legged platforms really show that this adaptation works well across different robot dynamics without needing to completely retrain everything from scratch for each new hardware type. It’s showing a lot of promise for making simulation-to-real transfer much more robust generally.

Dev: I'm still wondering about the long-term stability; how long can we rely on these learned models staying accurate if the robot wears down or if the environment changes in ways not seen during training? That’s a question I have when thinking about real-world reliability versus lab success.

Taro: That points toward future work, I think; ensuring that this adaptation framework can handle continuous online updates to those models as the robot operates over time, which is where it could truly become something useful for long-term autonomous operation in changing environments.

Rosa: So, EIDA gives us a powerful tool for platform-specific adaptation by learning execution dynamics from target data, showing a clear path toward more robust simulation-to-real transfers.

Dev: I think the practical impact here is that we can accelerate the development cycle for new navigation policies because we bypass the need to manually tune complex physical parameters for each robot.

Taro: For autonomy research, this implies we can build agents that are inherently more resilient to execution failures because they’ve been trained on how the real machine reacts when things go slightly off script.

The paper's summary: Rosa: So, to wrap up our discussion on EIDA, I want us to focus specifically on what the authors suggest as improvements, which involves building that dedicated module to learn how the low-level controller outputs translate into actual body-frame pose increments on the target robot and adding that separate causal model to predict the specific velocity feedback available to the policy during simulation.

Dev: That dual modeling approach sounds like it directly tackles both sides of the execution mismatch problem, which is exactly what we need when we move from a perfect simulation environment to a real-world system with inherent physical quirks.

Taro: The inclusion of that explicit history buffer feeding into the policy input also seems crucial because it gives the autonomy system information about recent execution responses, allowing it to anticipate how momentum and inertia will affect its next move, which is vital when dealing with dynamic obstacles.

Rosa: Precisely; by giving the policy this context about what just happened physically, we enable it to make decisions that are conditioned on reality rather than just the idealized physics of the simulator. This should lead to much smoother and more reliable navigation transfers in practice.

Dev: From my point of view, if this works as advertised, it means we can maintain those fast training speeds you mentioned because instead of using heavy, slow physics models for every iteration, we're using these learned interface models that are much lighter computationally.

Taro: I’m also thinking about the impact on complex tasks; if a robot can reliably learn to adapt its movement based on real execution feedback, it opens up possibilities for agents to handle messy, dynamic interactions in environments that aren't perfectly modeled initially.

Rosa: It really does show how we can improve navigation transfer significantly without having to reconstruct the entire low-level actuation dynamics of a complex robot from scratch, which is a massive engineering time saver.

Dev: But I still want to stress the deployment aspect; if this system relies on these fitted models, we need assurance that those models remain stable and accurate when deployed in live sensing scenarios over extended periods without requiring constant retraining.

Taro: That leads right into the future work mentioned—we need to explore how this framework can incorporate online adaptation so that it can handle long-term changes or wear on the robot itself, which is a key area for making this technology truly robust for field deployment.

The paper's improvements: Rosa: So, to wrap up our discussion on "EIDA: Execution-Interface Dynamics Adaptation for Real-to-Sim-to-Real Robot Navigation," this framework successfully bridges the gap between simulation and physical execution by learning the robot’s specific execution responses rather than trying to model every single actuator detail.

Dev: I agree, it’s a smart way to handle that gap without needing impossibly detailed models, and the fact that it works across different robot types is really encouraging for engineers designing new hardware.

Taro: It really shows how autonomy researchers can focus on learning robust adaptation mechanisms instead of spending all our time trying to perfectly recreate the physics of every single robot platform we encounter in the wild.

Rosa: And I'm excited because this approach suggests we can get policies trained in simulation that perform much better when deployed on real hardware, leading to more reliable robots in the field, as shown by those impressive results across varied platforms.

Dev: I just hope that the latency introduced by running these learned models during live deployment doesn't become a bottleneck for us when we are pushing for high-frequency control loops; that’s always a critical consideration when moving from simulation to real-time systems.

Taro: That’s exactly where the next phase needs to focus, because ensuring the stability and accuracy of these models over long periods in an evolving physical environment is what will determine their real-world utility.

Rosa: So, EIDA gives us a powerful tool for platform-specific adaptation by learning execution dynamics from target data, showing a clear path toward more robust simulation-to-real transfers.

Rosa: It’s a really solid piece of work, EIDA, because it proves we can improve navigation transfer by focusing on the interface between command and execution rather than trying to model every motor detail.

Dev: I'm still thinking about how we manage the loop rate during deployment; if the feedback loop becomes too sluggish due to these models, performance will suffer regardless of how good the policy is.

Taro: The long-term implication is that we move closer to truly generalized autonomy where policies are ready for deployment across a wider variety of physical systems without needing bespoke tuning every single time.

Conclusion: Rosa: So we’ve just finished looking at "EIDA: Execution-Interface Dynamics Adaptation for Real-to-Sim-to-Real Robot Navigation," and to recap, this framework learns the robot’s specific execution responses from real data to update simulator geometry and predict velocity feedback, which really helps improve navigation transfer.

Dev: That's right, Rosa; it’s a pragmatic way to handle the execution mismatch by fitting interface models instead of trying to model every single motor torque curve, which is a huge relief for the engineering side.

Taro: I think what stands out is how it gives the autonomy system information about recent execution responses through that velocity history buffer, allowing it to anticipate momentum and inertia when things go wrong in the real world.

Rosa: Exactly, Taro; that separation into motion prediction and velocity feedback prediction is smart because it lets us tackle those two different aspects of the execution gap distinctly. We’re not just modeling a path; we’re modeling how that path *feels* in physical terms through the velocity history component they've added.

Dev: I see the implication there is that this separation allows the policy to be trained efficiently in simulation while still being informed by execution responses relevant to navigation, which means we can use lighter simulator models for training.

Taro: That structure suggests they are addressing two distinct challenges: accurately predicting where the robot *should* go based on its commands, and understanding what kind of *feedback* we can actually rely on when we're running this in reality.

Rosa: And for the improvements, EIDA suggests using this execution-interface dynamics adaptation framework to learn those target system responses so we can update simulator geometry during policy training, which leads to much smoother and more reliable navigation transfers.

Rosa: Overall, I think EIDA is a really important contribution because it shows how we can improve navigation transfer by focusing on learning the execution interface directly from target data, rather than trying to perfectly recreate the underlying physics of every single actuator.

Dev: I just hope the latency introduced by running those fitted models during deployment doesn't become a bottleneck for real-time control; that’s always the critical hurdle when you move from simulation to live systems.

Taro: I think that’s something we need to monitor closely in future work, because while it improves transfer, performance under extreme latency conditions is another area where we can push this further.

Rosa: Well, that wraps up our discussion on EIDA: Execution-Interface Dynamics Adaptation for Real-to-Sim-to-Real Robot Navigation. It's a really neat way to get better navigation transfer by focusing on the interface between command and execution rather than trying to model every motor detail. Thanks for tuning in with us today.

Dev: We'll keep an eye on how this framework handles those loop rate challenges in the coming months to see how it holds up under stress, but I’m ready for whatever the next paper brings.

Taro: I’m looking forward to seeing how these adaptation techniques can be integrated into larger, more complex agentic systems that need to react dynamically to unforeseen physical situations.

Yiwei Qian, Shanze Wang, Qingyuan Hu, Xinming Zhang, Wei Zhang

Eastern Institute of Technology, Ningbo, China · National University of Singapore · Department of Aeronautical and Aviation Engineering, The Hong Kong Polytechnic University, Hong Kong · University of Science and Technology of China

cs.RO

Submitted: 2026-10-01

Updated: 2026-10-01

Comments: 8 pages, 7 figures, 3 tables

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

Importance score: 80/100

The gist: Simulation-to-robot transfer can fail when velocity commands produce motion and feedback that differ from those modeled during policy training, leading to navigation failures in physical execution.

Key concepts

Pose Model: This model predicts the change in the robot's body-frame pose based on recent control inputs. It uses a feature vector containing current velocity estimates and command histories to update the simulated geometry, bridging the gap between commanded motion and actual physical movement.
Observation Model (ARX): This is a causal autoregressive model fitted to recorded velocity estimates. It learns how the available feedback changes over time based on past states and commands. This allows the policy to incorporate history-dependent execution responses into its decision-making process.
Execution Interface Dynamics Adaptation (EIDA): EIDA is the overall framework that learns the interface between simulation and reality. It updates simulator geometry using pose prediction and predicts velocity feedback using an ARX model, enabling policies trained in simulation to successfully navigate physical robots by accounting for real-world execution dynamics.

Terminology

Adaptation — 27× in this paper · explained in 1 episode
Execution-Interface Dynamics Adaptation — 12× in this paper
Ablation — 7× in this paper · explained in 1 episode
Actor — 6× in this paper · explained in 3 episodes
Accuracy — 4× in this paper · explained in 1 episode
Reinforcement Learning — 4× in this paper · explained in 4 episodes
Benchmark — 3× in this paper · explained in 2 episodes
Deep Reinforcement Learning — 3× in this paper · explained in 2 episodes
Robustness — 3× in this paper · explained in 5 episodes
Soft Actor-Critic — 3× in this paper
World Model — 3× in this paper · explained in 7 episodes
Ablation Studies — 2× in this paper · explained in 1 episode
Online Adaptation — 2× in this paper · explained in 3 episodes
Ablation study — 1× in this paper · explained in 1 episode
Agentic System — 1× in this paper · explained in 2 episodes
Benchmarking — 1× in this paper · explained in 3 episodes
Core — 1× in this paper · explained in 2 episodes
Deep Reinforcement Learning (DRL) — 1× in this paper · explained in 2 episodes
Fidelity — 1× in this paper · explained in 2 episodes
IEEE International Conference on Robotics and Automation — 1× in this paper
Loss Function — 1× in this paper · explained in 2 episodes
Regularization — 1× in this paper · explained in 3 episodes
Soft Actor-Critic (SAC) — 1× in this paper · explained in 2 episodes

Summary

Simulation-to-robot transfer can fail when velocity commands produce motion and feedback that differ from those modeled during policy training, leading to navigation failures in physical execution. This work presents Execution-Interface Dynamics Adaptation (EIDA), a framework that fits target-platform execution data to update simulator geometry and predict policy-facing velocity feedback, demonstrating improved navigation transfer without reconstructing detailed actuator dynamics.

How it works

The EIDA framework addresses the gap between simulation and reality by learning the execution interface from target system data. This involves two primary models: one for predicting motion and another for predicting velocity feedback. The pose model uses recent control inputs to predict body-frame pose increments, which directly update the simulator geometry. Specifically, it utilizes a state–command feature vector, denoted as 'xt', which includes the current velocity estimate, the current command, and a history of preceding commands: xt = [s⊤t, u⊤t,..., u⊤t−Hu]⊤. This predicted increment is then used to update the simulated pose: pbt+1 = pbt + R(ψbt)δpb t, ψbt+1 = wrap(ψbt + δψb t).

A separate causal autoregressive model is fitted to recorded velocity estimates to reproduce the feedback available to the policy. This model takes an affine form: sbt+1 = gϕ(st, ut) = Asst + Auut + b, where As, Au ∈ R m×m and b ∈ R m are fitted coefficients. This component allows the policy to account for history-dependent execution responses by incorporating a short history of velocity feedback into its input: The recent velocity observations help the policy account for history-dependent execution responses.

Model Identification

The identification process involves training two separate models using recorded data. The pose model is trained to predict body-frame pose increments, while the observation model (the ARX model) is fitted to reproduce velocity feedback. The training methodology involves pairing recorded command histories and available velocity estimates with adjacent reference poses. For the pose model, the loss function minimizes the difference between predicted and actual increments: L1 = P i∈B wi ρ (fθ(xi, ∆ti) − δi) ⊘ σδ. This is trained using a weighted, single-step loss where weights 'wi' balance data families and trajectory groups.

The observation model, the ARX model, is fitted to reproduce the velocity feedback. It is first fitted using weighted ridge regression and then frozen during pose-model training. The data used for fitting includes recorded controller commands and available velocity estimates at the collection cutoff. The training windows require complete command histories and remain within continuous valid trajectory segments; pose gaps are not interpolated.

Policy Learning and Deployment

A navigation policy, implemented using a Soft Actor-Critic (SAC) algorithm, is trained with both execution-fitted models fixed. The policy input is conditioned on recent velocity observations to capture motion responses: ot = [l⊤t, dt, βt, s⊤t, s⊤t−1,..., s⊤t−Hs]⊤. This history of velocity estimates, denoted as 's', provides the policy with information about recent execution response rather than control inputs.

During deployment on a physical robot, the existing low-level controller and state estimator are retained. The execution-fitted simulator is replaced by live sensing and sensor feedback. Specifically, physical motion and sensor feedback replace the learned simulation interface, while the existing low-level controller is retained. The policy input at deployment comprises live LiDAR, localized target geometry, and a short history of velocity estimates.

Validation and Results

Validation was conducted across wheeled (Jackal) and legged (Go2) platforms. The results showed that EIDA significantly improved navigation transfer. On the physical Unitree Go2, EIDA reached the goal without collision in all 20 staticscene trials, compared with 4 of 20 for the baseline. Across 100 benchmark navigation environments evaluated in a separate physics-based simulator, EIDA achieved the highest success rate and navigation score among the compared learned policies. In physical Go2 trials, EIDA reached the goal without collision in all 20 staticscene trials, compared with 4 of 20 for the baseline. Furthermore, ablation studies confirmed that components like motion fitting and velocity history each made a distinct contribution to the complete configuration. EIDA achieved the highest success rate and score under both planner settings.

Conclusion

EIDA presents an execution-interface dynamics adaptation framework that learns target-system execution responses for policy training. The framework enables platform-specific adaptation through an existing velocity-command interface without reconstructing low-level actuation dynamics, showing that this approach can improve navigation transfer while preserving efficient parallel policy training.

Improvements for AI systems

Based on the provided scientific paper, here are specific improvements that can be made to existing AI systems, along with what those improved systems can achieve:

) An execution-interface dynamics adaptation framework (EIDA) that learns body-frame pose increments from execution data collected on the target system and uses them to update simulator geometry during navigation policy training.

• A separated representation of motion evolution and velocity feedback observable to the policy, together with recent observations that capture temporally dependent execution responses.

Improved AI System: A Transfer-Aware Policy Training Engine utilizing EIDA.

Specific Improvements & Capabilities:

The system will incorporate a dedicated module to learn the mapping between low-level controller outputs (velocity commands) and resulting body-frame pose increments, specifically tailored for the target robot platform.
This learned pose increment model will be used dynamically within the simulator to update the geometric state of the simulation in real-time during policy training. This means that when an agent learns a maneuver in simulation, it learns not just a path, but how that path translates into physical body motion on the specific robot hardware.
The system will include a separate causal model (ARX) trained specifically on recorded velocity feedback from the target robot execution data to predict the velocity signals available to the policy during simulation. This allows the policy network to account for temporally dependent execution responses (i.e., how recent commands affect current feedback).
The AI system will integrate a Velocity History Buffer that feeds a short history of recent velocity estimates directly into the policy's state input, allowing it to make decisions based on the robot's recent dynamic response rather than just instantaneous feedback.

Improved System Capabilities:

Maneuver Robustness: The improved system can train navigation policies in lightweight simulators (like FlashNav) that are significantly more robust to execution mismatch. This means policies trained in simulation will perform much better when transferred to the physical robot because they are conditioned on the actual, non-linear dynamics of the target platform.
Reduced Transfer Gap: It directly addresses the execution gap where simulated motion and physical execution differ. The system can achieve significantly higher success rates (as demonstrated by EIDA achieving 89.33% success in simulations vs. 71.22% for Nominal baseline) when deployed on real hardware, even without needing to reconstruct complex low-level actuator dynamics (which is computationally expensive).
Faster Policy Learning: By using a lightweight simulator enhanced by these fitted models instead of slower, detailed physics models, the system can maintain efficient GPU-parallel training speeds while still achieving superior navigation performance compared to baseline methods like Nominal or RWM-U.
Enhanced Dynamic Adaptation: The inclusion of velocity history allows the policy to anticipate and react appropriately to momentum and inertia effects caused by preceding commands, leading to smoother trajectories and better handling of dynamic obstacles in real-world scenarios (e.g., successfully navigating a pedestrian obstruction).