REVIEW 2 major objections 5 minor 16 references
Judo: A User-Friendly Open-Source Package for Sampling-Based Model Predictive Control
T0 review · 2 major / 5 minor · reviewed 2026-08-06 · deepseek-v4-flash
Pith's one-line read Judo is an open-source Python package that aims to make sampling-based model predictive control easy to prototype, tune, and deploy, with control updates fast enough for real-time use on consumer hardware.
desk verdict Judo is a genuinely useful open-source package for sampling-based MPC; the main weakness is an overbroad 'real-time' claim that the reported benchmarks do not fully support. read the letter →
The pith
A machine-rendered reading of the paper's core claim, the machinery that carries it, and where it could break.
The reading
What carries the argument
The load-bearing abstraction is the pair of interfaces Task and Optimizer. A Task defines the reward used to score rollouts and knows how to reset the system, while an Optimizer implements two methods: sample_control_knots, which proposes candidate control splines, and update_nominal_knots, which picks the best proposal from their rewards. Around this core, the package layers a multi-threaded physics engine for parallel rollouts, a browser-based visualizer that automatically turns configuration dataclasses into sliders and checkboxes, and an asynchronous dataflow layer so controller, simulator, and visualizer run as independent communicating nodes. This machinery lets a user write roughly a page of code to define a new task or controller and have it run with real-time updates and interactive tuning.
What would settle it
Measure the wall-clock period of a closed-loop run on hardware, from state observation to executed action, including physics stepping and middleware communication; if for any benchmark this period exceeds the robot's required control interval, the claim that Judo achieves real-time performance for that task is refuted.
Extended reading notes
Core claim
The central claim is that carefully architected software—not just faster simulators—is what stands between the community and widespread use of sampling-based MPC. Judo splits the control loop into Task objects that evaluate rollout rewards and Optimizer objects that decide how to sample and update control knots, while a browser-based GUI auto-generates tuning controls from configuration fields. Asynchronous nodes keep controller, simulator, and visualizer decoupled, so swapping the simulation for a hardware interface does not require rewriting the controller. The authors report benchmark timings for the nominal control update in three tasks with three optimizers, finding millisecond-level updates on a laptop and faster updates on a high-core-count server, with the largest task taking 15–52 ms. They interpret these numbers as evidence that Judo is fast enough for real-time control and that the performance gap between consumer and server hardware mainly reflects sampling-based MPC's dependence on parallel rollouts.
Load-bearing premise
The load-bearing premise is that the reported control-update timing by itself establishes real-time performance, because the paper does not specify each robot's required control frequency or measure the full closed-loop latency including physics stepping and communication overhead.
Editorial extensions
If this is right
- A user can define a new task or optimizer with only a few methods and immediately tune it live in the GUI, cutting the time from idea to running controller.
- Because controller and simulator run asynchronously, the same controller code can be deployed on hardware by replacing the simulation node with a hardware interface, preserving the visualizer and tuning loop.
- The benchmark numbers give researchers a common reference point: on a laptop, standard optimizers update their control plan in single-digit milliseconds on simple tasks, so sampling-based MPC is viable on consumer machines.
- On a high-core-count machine, performance is maintained even at 120 threads, indicating that rollout parallelism scales.
- Standardized tasks such as cartpole, cylinder push, and cube rotation provide a shared suite for comparing new sampling-based MPC algorithms.
Reading between the lines
- A strict end-to-end latency test would clarify whether 'real-time' holds: the paper reports control-update timing only, and the full closed-loop period also includes physics stepping and inter-node communication.
- The modular backend interface suggests the same Task/Optimizer abstraction could be mounted on a GPU-accelerated simulator, which would likely shrink the consumer/server performance gap the paper observes.
- A natural next experiment is measuring how much the GUI and one-line registration reduce time-to-first-controller compared with writing infrastructure from scratch.
- If open-source adoption follows, the three benchmark tasks could become a de facto standard for comparing sampling-based MPC algorithms, making results easier to reproduce across groups.
Editorial analysis
A structured set of objections, weighed in public.
Referee Report
Summary. The paper introduces Judo, an open-source Python package for sampling-based model predictive control (MPC). It provides task and optimizer interfaces, built-in implementations of predictive sampling, CEM, and MPPI, an interactive GUI, and an asynchronous architecture using the dora middleware with MuJoCo as the physics backend. The authors argue that Judo accelerates research and eases simulation-to-hardware transfer, and they support the performance claim with control-update timing benchmarks on a consumer laptop and a workstation across three tasks (cartpole, cylinder push, and LEAP-hand cube rotation) and three optimizers. The central claim is that Judo is user-friendly, performant, and achieves real-time performance.
Significance. If the performance claims hold, Judo would fill a useful gap in open-source sampling-based MPC tooling: the API is simple and extensible, the GUI lowers the barrier for interactive tuning, and the asynchronous design could ease sim-to-real transfer. The paper's strengths include the public repository, concrete code examples in Listings 1 and 2, and the use of standard mean-and-standard-deviation timing data on two hardware tiers. The central weakness is that the 'real-time' claim rests solely on average control-update times without reference to the required control period or full closed-loop latency, which is a load-bearing issue for the abstract's main promise.
major comments (2)
- [IV, Table II] The claim that Judo 'achieves real-time performance' (abstract) and is 'viable for real-time control' (Section IV) is not supported by the reported data alone. Table II lists mean control-update times, but no task-specific required control period, no tail latencies (p95/max), and no measurement of the full asynchronous loop (simulation stepping, dora IPC, visualization, action interpolation) are reported. Real-time is a deadline property: on the ThinkPad the leap_cube update averages 48.8 ms, which would miss a 20 ms deadline if the task needs 50 Hz control. Please either report the control period and end-to-end latency for each task, or soften the claim to 'fast control updates' in the abstract and Section IV.
- [IV, Table II] The benchmark section does not report the planning hyperparameters for each task (horizon, number of rollouts, number of control knots, MuJoCo timestep), so the timings cannot be reproduced or meaningfully compared. For example, the leap_cube timings would change substantially with different numbers of rollouts. Include these parameters in Table II or a companion table, and specify the exact thread count for each reported configuration beyond the coarse '10 threads' versus '120 threads' labels.
minor comments (5)
- [III-A, Listing 1] The `return` statement on line 20 is missing a space after `return` (`returnvertical_rew`), which is a Python syntax error; as printed, the minimal example will not run.
- [Abstract] The phrase 'real-time performance' is too strong for the evidence in Section IV; consider 'real-time control-update performance' or a similar qualification.
- [Table I] Hydrax is listed with 'Async \checkmark' but it uses MJX on GPU; consider clarifying what 'Async' means (multi-threaded versus middleware-based asynchronous execution) to avoid conflation.
- [III-C] The dora IPCs are said to be 'zero-copy' on the same device; specify whether this applies to all data types and whether the benchmarks include IPC overhead.
- [References] Reference [3] has a typo in the title ('mujoco warp' should be 'mujoco_warp' or similar) and the URL appears malformed.
Circularity Check
No significant circularity: Judo is a software/benchmark paper whose timing claims are direct measurements, not fitted predictions or self-citation-derived results.
full rationale
This paper is a systems contribution describing a software package, not a derivation. Its central claims are that Judo provides usable interfaces, asynchronous execution, and real-time control-update speeds. The support for the real-time claim is Table II, which reports measured average control-update timings of Judo's own optimizer loop on specified hardware. These numbers are empirical benchmarks, not quantities predicted from fitted parameters, and no equation in the paper reduces to its own output by construction. The algorithms (Algorithm 1, predictive sampling, CEM, MPPI) are presented as standard formulations with citations to prior literature, including the authors' own DROP paper [6], but that citation is contextual related work and is not the load-bearing justification for Judo's functionality or measured performance. The potential concern that 'real-time' is asserted without reporting required control frequencies or full closed-loop latency is a missing-evidence or correctness-risk issue, not circularity. No self-definition, fitted-input-as-prediction, or self-citation chain forces the paper's conclusions. The paper is self-contained against its benchmarks, so the appropriate finding is no significant circularity.
Assumptions & free parameters
assumptions (3)
- domain assumption Sampling-based MPC as described in Algorithm 1 is a valid control approach for the tested tasks.
- domain assumption MuJoCo accurately simulates the dynamics of the benchmark tasks.
- domain assumption The middleware (dora), visualizer (viser), and config system (hydra) perform as described.
Cite this review
Pith. "Pith review of Judo: A User-Friendly Open-Source Package for Sampling-Based Model Predictive Control." pith.science (2026). https://pith.science/paper/4VRZBZ6E
@misc{pith2026250617184,
author = {Pith},
title = {Pith review of: Judo: A User-Friendly Open-Source Package for Sampling-Based Model Predictive Control},
year = {2026},
howpublished = {\url{https://pith.science/paper/4VRZBZ6E}},
note = {Machine review of arXiv:2506.17184}
}
read the original abstract
Recent advancements in parallel simulation and successful robotic applications are spurring a resurgence in sampling-based model predictive control. To build on this progress, however, the robotics community needs common tooling for prototyping, evaluating, and deploying sampling-based controllers. We introduce Judo, a software package designed to address this need. To facilitate rapid prototyping and evaluation, Judo provides robust implementations of common sampling-based MPC algorithms and standardized benchmark tasks. It further emphasizes usability with simple but extensible interfaces for controller and task definitions, asynchronous execution for straightforward simulation-to-hardware transfer, and a highly customizable interactive GUI for tuning controllers interactively. While written in Python, the software leverages MuJoCo as its physics backend to achieve real-time performance, which we validate across both consumer and server-grade hardware. Code at https://github.com/bdaiinstitute/judo.
Figures
Reference graph
Works this paper leans on
-
[1]
Juan Alvarez-Padilla, John Z. Zhang, Sofia Kwok, John M. Dolan, and Zachary Manchester. Real- time whole-body control of legged robots with model- predictive path integral control, 2024. URL https://arxiv. org/abs/2409.10469
arXiv 2024
-
[2]
The MJX Developers. Mjx. https://github.com/ google-deepmind/mujoco/tree/main/mjx, 2024
work page 2024
-
[3]
The Newton Developers. Mujoco warp. https://github. com/google-deepmind/mujoco warp, 2024
work page 2024
-
[4]
Predictive sampling: Real-time behaviour synthesis with mujoco,
Taylor Howell, Nimrod Gileadi, Saran Tunyasuvunakool, Kevin Zakka, Tom Erez, and Yuval Tassa. Predictive sampling: Real-time behaviour synthesis with mujoco,
-
[5]
Hydrax: Sampling-based model predic- tive control on gpu with jax and mujoco mjx, 2024
Vince Kurtz. Hydrax: Sampling-based model predic- tive control on gpu with jax and mujoco mjx, 2024. https://github.com/vincekurtz/hydrax
work page 2024
-
[6]
Li, Preston Culbertson, Vince Kurtz, and Aaron D
Albert H. Li, Preston Culbertson, Vince Kurtz, and Aaron D. Ames. DROP: Dexterous reorientation via online planning. In2025 IEEE International Confer- ence on Robotics and Automation, 2025. Available at: https://arxiv.org/abs/2409.14562
arXiv 2025
-
[7]
Pytorch mppi: Model predictive path integral with approximate dynamics
University of Michigan ARM Lab. Pytorch mppi: Model predictive path integral with approximate dynamics. https://github.com/UM-ARM-Lab/pytorch mppi, 2024
work page 2024
-
[8]
Sampling-based model predictive control leverag- ing parallelizable physics simulations, 2023
Corrado Pezzato, Chadi Salmi, Max Spahn, Elia Tre- visan, Javier Alonso-Mora, and Carlos Hernandez Cor- bato. Sampling-based model predictive control leverag- ing parallelizable physics simulations, 2023
work page 2023
Show all 16 references
-
[9]
DORA: Dataflow-oriented robotic architecture
Haixuan Xavier Tao and Philipp Oppermann. DORA: Dataflow-oriented robotic architecture. https://github. com/dora-rs/dora, 2025
2025
-
[10]
Viser: A real-time web visualizer for 3d content
The NerfStudio Team. Viser: A real-time web visualizer for 3d content. https://github.com/nerfstudio-project/ viser, 2023
2023
-
[11]
Theodorou
Bogdan Vlahov, Jason Gibson, Manan Gandhi, and Evan- gelos A. Theodorou. Mppi-generic: A cuda library for stochastic optimization, 2024. URL https://arxiv.org/abs/ 2409.07563
2024
-
[12]
Full-order sampling-based mpc for torque- level locomotion control via diffusion-style annealing,
Haoru Xue, Chaoyi Pan, Zeji Yi, Guannan Qu, and Guanya Shi. Full-order sampling-based mpc for torque- level locomotion control via diffusion-style annealing,
-
[13]
Hydra - a framework for elegantly con- figuring complex applications
Omry Yadan. Hydra - a framework for elegantly con- figuring complex applications. Github, 2019. URL https://github.com/facebookresearch/hydra
2019
-
[14]
Zhang, Taylor A
John Z. Zhang, Taylor A. Howell, Zeji Yi, Chaoyi Pan, Guanya Shi, Guannan Qu, Tom Erez, Yuval Tassa, and Zachary Manchester. Whole-body model-predictive control of legged robots with mujoco, 2025. URL https://arxiv.org/abs/2503.04613
2025
-
[2022]
URL https://arxiv.org/abs/2212.00541
-
[2024]
URL https://arxiv.org/abs/2409.15610
Reviewed August 6, 2026 · model on record in the stance chip above.
Discussion (0). Sign in to comment.