ManiFlow-tb

ManiFlow-tb

The low-level action model of allenai's ToyBlocks block-stacking project, trained on simulated Franka arm data to pick, place and rotate three blocks on a table. A research model for robotics.

Made by allenai 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: ManiFlow-tb drives the arm's low-level movements in ToyBlocks, a block-stacking robot project from allenai. Its training data came from a simulated Franka arm handling three blocks on a table, in two tasks: pick-and-place and rotating a block in place. It is evaluated through ToyBlocks' own policy server.

Who it suits: It suits robotics researchers who work on manipulation and want a trained low-level policy to evaluate in the ToyBlocks simulation.

Industry | Who uses it | How they use it | Example
Robotics research | Manipulation researchers | Use it as the low-level action model in ToyBlocks | Evaluate it on three-block tabletop tasks
Imitation learning | Teams studying flow-based policies | Study a policy trained with flow matching and consistency training | Compare its results across repeated runs
Simulation benchmarking | Evaluation engineers | Run the closed-loop eval on held-out episodes | Measure success and collision counts over 128 episodes

You can skip it if you want to drive a physical robot, since the card reports only simulation results.

Where to use it:

• The ToyBlocks simulation and its policy server
• Python on Windows, macOS and Linux, to download the files
• GPU machines, which the card used for training and evaluation

Use case | Who | What they get back
Policy evaluation | Researchers | Success and collision counts over held-out episodes
Action prediction | Robotics developers | Chunks of 25 actions for the robot arm
Training study | Learning researchers | A checkpoint trained for 200,000 steps

How to set it up: You need these first:

• Python on Windows, macOS or Linux
• The ToyBlocks code and an evaluation dataset from that project
• Enough GPU capacity to run the simulation and the model

1. Install or update the Hugging Face download client.
2. Download this repository into a local folder.
3. Keep the layout as it is, with config.yaml next to the checkpoints folder, since the server reads settings from it.
4. Run the ToyBlocks evaluation script against the weights file.

pip install -U huggingface_hub
hf download allenai/maniflow-tb --local-dir maniflow-tb

How to use it: You evaluate the model through ToyBlocks, pointing its launch script at the weights file and an evaluation dataset.

python scripts/launch_eval.py --policy maniflow \
  --model-path maniflow-tb/checkpoints/steps_200000_model.safetensors \
  --dataset-path <ToyBlocks eval dataset> --expert-timeout-scale 3.0 ...

Tool | What it does
scripts/launch_eval.py | Runs the closed-loop evaluation in the ToyBlocks simulation
--policy maniflow | Selects this model as the policy
--model-path | Points to the weights file in the checkpoints folder
--dataset-path | Points to the ToyBlocks evaluation dataset
--expert-timeout-scale | Sets the time limit as a multiple of the longest expert demonstration

Example: You run the evaluation script on 128 held-out three-block episodes with the time limit scaled to 3. The card's four runs reached a success rate of 54 to 59 percent, with 30 to 38 collisions in each run.

For newcomers and experts: ManiFlow-tb is a robot control model, not a chatbot. It reads camera images and the arm's state, then outputs the next moves. A good first step is the download command, then ToyBlocks' own instructions to run the evaluation.

For readers who know the field, it uses a multimodal action network with a 12-layer diffusion-transformer head and 322.5M parameters. Inputs are two RGB views, a 9-dimensional state, the task name and a target heatmap from a high-level policy. It outputs 25 absolute actions per chunk. The last action dimension is a play mode, which you must feed back when it is 1 or 0.

High-level policy sets a target heatmap
Front and gripper images enter with state
Action head runs 12 flow steps
A chunk of 25 actions comes out
Play mode is fed back to the model

Good to know:

• Safety: no safety benchmarking was done, and the card limits use to its research protocol.
• Time limit: with the default 30 seconds, most episodes time out, and only 26 to 28 of 128 succeed.
• Repeat runs: scores vary a little from run to run, since neither the simulator nor batched inference gives bit-identical results.
• Oracle plan: the evaluation takes the high-level plan from the recorded task, so it scores this model alone.
• Weights: they are the non-EMA weights from step 200,000.

Title: Success rate over 128 episodes in four runs
Run 1: 57%
Run 2: 59%
Run 3: 59%
Run 4: 54%

• License: Apache 2.0, for the weights and the training code.
• Cost to run: none named.
• Data it reaches: the images and states from the ToyBlocks simulation. The text available here names no network use.
• Not for: use outside the provided research protocol, as the card's safety note states.

On Hugging Face, 15 November 2026

• Task: robotics
• Formats: Safetensors
• Downloads in the last 30 days: 89
• Likes: 3
• License: apache-2.0
• Tags: safetensors, robotics, manipulation, franka, flow-matching, maniflow, toyblocks

Links

• Model: https://huggingface.co/allenai/maniflow-tb
• Files: https://huggingface.co/allenai/maniflow-tb/tree/main

Get the model

Download its files with Hugging Face's command line:

pip install -U huggingface_hub
hf download allenai/maniflow-tb

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