H-JEPA

H-JEPA

Provides trained hierarchical world-model checkpoints for visual planning in simulated mazes, cube and push tasks, and DROID robot data. For robotics and world-model researchers reproducing the paper.

Made by jepa-world-models on Hugging Face. These notes are Mindket's, written from its model page and model card; the model's own files and license are on Hugging Face.

About

What it is: This repository holds the trained checkpoints from the H-JEPA paper, which learns hierarchical world models for visual planning from end to end. There are checkpoints for four simulated environments and one real-robot data set, each in several variants and seeds. The paper's code release trains, evaluates and reproduces the planning results with them.

Who it suits: Researchers who work on world models and robot planning and want the exact checkpoints behind the paper's results.

Industry | Who uses it | How they use it | Example
Robotics research | Planning researchers | Reproduce the paper's planning results from the released models | Evaluate a cube task checkpoint
AI research | World-model researchers | Compare flat and hierarchical models with 2, 3 and 4 levels | H-JEPA against HWM at the same depth
Education | Graduate students | Study hierarchical planning with ready-trained models | Load a checkpoint and inspect its levels
Robot learning | Data scientists | Test models trained on DROID robot data | Use the DROID checkpoints at epoch 100

You can skip it if you want a model to run as is, since the checkpoints need the paper's code release to load and evaluate.

Where to use it: It runs in Python with PyTorch, using the code release from the paper's authors, on Windows, macOS or Linux.

• Python with PyTorch
• The paper's code release, with its h_jepa folder on the Python path
• A local folder named by the HJEPA_HOME setting, where the code reads checkpoints

Use case | Who | What they get back
Planning reproduction | Researchers | The paper's planning results, using a checkpoint as the policy
Model comparison | World-model teams | Models with different numbers of levels, ready to evaluate
Real-robot study | Robot learning teams | Models trained on DROID data

How to set it up: You need Python with pip, PyTorch, the code release and room for the checkpoints, which come to roughly 2 to 3 GB per folder.

• Python with pip and PyTorch
• The paper's code release
• The HJEPA_HOME setting pointing to a folder for checkpoints

1. Install the Hugging Face download tool.
2. Download the four simulation environments, which hold 84 checkpoints.
3. Download the DROID checkpoints separately, which hold 9.
4. Narrow a download to one environment or one seed with an include filter if you need only part.

pip install -U huggingface_hub

hf download jepa-world-models/h-jepa --local-dir $HJEPA_HOME/ckpts --exclude "droid/*"
hf download jepa-world-models/h-jepa --local-dir $HJEPA_HOME/ckpts --include "droid/*"

How to use it: Load a checkpoint from the code release's h_jepa folder, since the files are pickled modules. To reproduce the planning results, pass a checkpoint as the policy to the evaluation script or run the evaluation scripts, as the code release README describes.

import torch

model = torch.load("cube/cube_hjepa_l3/seed42/cube_hjepa_l3_object.ckpt", weights_only=False)

Tool | What it does
_object.ckpt | The trained model for one run
normalizer.pt | Holds the action and proprioception normalization
eval.py | Evaluates a checkpoint passed as the policy
HJEPA_HOME | Names the folder where the code reads checkpoints

Example: Load the three-level H-JEPA checkpoint for the cube task with seed 42, then pass it as the policy to the evaluation script. The code release README says how to run the simulation tests and compare with the paper's planning results.

For newcomers and experts: A world model is a network that predicts what a scene will look like after an action, so a robot can plan before it moves. This one stacks several levels, so it can plan over longer horizons. A first small try is to download one environment folder and load a single checkpoint.

For experts, each environment folder holds seven models: LeWM, H-JEPA with 2, 3 or 4 levels, and HWM with 2, 3 or 4 levels, each at seeds 42, 43 and 44. The DROID set has LeWM with an inverse dynamics model, HWM with 2 levels and H-JEPA with 2 levels, at seeds 1, 1000 and 10000. Each run folder holds the model and a normalizer, in the layout the training code writes.

Train the world model in the code release
Save the model and normalizer per seed
Download the checkpoints into HJEPA_HOME
Load them with the code on the path
Run the evaluation to plan with the policy

Good to know: The checkpoints are pickled Python objects, so only load files from sources you trust.

• Pickle: The model files need weights_only set to False, which runs the pickle loader.
• Counts: There are 84 simulation checkpoints and 9 DROID checkpoints.
• DROID: Those models were trained on DROID data, and the card asks you to cite DROID when using them.

Title: Download size per folder in GB
Ant: 2.6 GB
Four-room: 1.7 GB
Cube: 2.7 GB
Push-T: 2.7 GB
DROID: 2.7 GB

• License: MIT, the same as the code release. The DROID data behind some checkpoints is CC BY 4.0.
• Cost to run: none named, the source lists no API key, account or paid service.
• Data it reaches: the checkpoints you download, and the evaluation datasets that the code release uses.
• Not for: loading without the code release, since the checkpoints are pickled modules that need it.

On Hugging Face, 13 November 2026

• Task: robotics
• Library: pytorch
• Downloads in the last 30 days: 0
• Likes: 25
• License: mit
• Quantized versions: 1
• Tags: pytorch, world-models, jepa, planning, robotics

Links

• Model: https://huggingface.co/jepa-world-models/h-jepa
• Files: https://huggingface.co/jepa-world-models/h-jepa/tree/main

Get the model

Download its files with Hugging Face's command line:

pip install -U huggingface_hub
hf download jepa-world-models/h-jepa

Then follow the usage in its model card. Nothing in this kit runs by itself.