Griffin Alpha-S, RoboTwin 2.0 fine-tune (flow-matching head)

The default head of Griffin Alpha-S: a 910M-parameter flow-matching action expert attached layer-by-layer (mixture-of-transformers) to a Qwen3-VL-4B backbone that was pre-trained on a multi-embodiment robot-data mixture. Inference integrates 10 Euler steps from noise to a 50-step action chunk.

Fine-tuned from griffinlabs/Griffin-Alpha-S on RoboTwin 2.0 aloha-agilex, clean setting only: all 50 tasks, 50 episodes each (2,500 episodes, 549,787 frames), 6 epochs = 25,776 steps at an effective batch of 128, full fine-tune of backbone and expert. This is the 6-epoch final; no checkpoint selection was performed (RoboTwin has no offline validation split), so quote it as "the 6-epoch final, unselected".

What is baked in

Policy type griffin_alpha; cameras observation.images.cam_high, observation.images.cam_left_wrist, observation.images.cam_right_wrist (prompt order) at 480x640; 14-D state and action ([left arm x6, left gripper, right arm x6, right gripper], joint positions) over the canonical 32-wide head; n_action_steps=50 in the config. The results below were produced executing 25 of the 50 predicted steps before replanning (the RoboTwin client's replan_steps=25); pass n_action_steps=25 to reproduce them.
Relative actions ON (use_relative_actions=true, relative_exclude_joints=["gripper"]): the twelve arm dimensions are predicted relative to the current observation.state, the two grippers absolute. The action feature names are stored in the config and processors, so the mask reloads as saved.
Prompt header [embodiment: Aloha AgileX bimanual, 2 grippers; arm control mode: joint_position]; include_proprio=true, condition_on_subtask=true, apply_inference_center_crop=true, num_inference_steps=10.
Normalization statistics from the RoboTwin clean training corpus (quantile normalization of state and of the relative actions).

RoboTwin 2.0 results

Closed loop in RoboTwin 2.0 (SAPIEN), 50 tasks x 100 episodes per setting, single seed, 10 Euler steps, 25 of the 50 predicted steps executed per replan, unseen instructions. Training used demo_clean only, so the two columns are an in-distribution / domain-randomization-generalization pair and must be quoted together: the demo_randomized figure is depressed relative to a model trained on randomized data and is not comparable to published RoboTwin leaderboard numbers.

	`demo_clean`	`demo_randomized`	delta
mean over 50 tasks	59.8	46.2	+13.6
successful episodes	2989 / 5000	2310 / 5000
zero-success tasks	0	0

Clean beats randomized on 45 of 50 tasks, is worse on 4, tied on 1. The range is wide: adjust_bottle and click_bell at 100% down to open_microwave at 2%, with precise bimanual placement (handover_block, hanging_mug, place_can_basket) in single digits.

Per-task success rate (%), 100 episodes each

task	`demo_clean`	`demo_randomized`
`adjust_bottle`	100	77
`beat_block_hammer`	60	49
`blocks_ranking_rgb`	58	48
`blocks_ranking_size`	16	6
`click_alarmclock`	98	90
`click_bell`	100	84
`dump_bin_bigbin`	82	79
`grab_roller`	98	74
`handover_block`	7	1
`handover_mic`	68	14
`hanging_mug`	7	4
`lift_pot`	79	22
`move_can_pot`	39	24
`move_pillbottle_pad`	66	49
`move_playingcard_away`	94	84
`move_stapler_pad`	17	9
`open_laptop`	93	81
`open_microwave`	2	10
`pick_diverse_bottles`	57	38
`pick_dual_bottles`	89	63
`place_a2b_left`	74	50
`place_a2b_right`	66	38
`place_bread_basket`	62	64
`place_bread_skillet`	66	50
`place_burger_fries`	79	91
`place_can_basket`	4	3
`place_cans_plasticbox`	89	66
`place_container_plate`	94	78
`place_dual_shoes`	43	32
`place_empty_cup`	97	83
`place_fan`	32	23
`place_mouse_pad`	20	16
`place_object_basket`	60	22
`place_object_scale`	70	44
`place_object_stand`	76	68
`place_phone_stand`	43	38
`place_shoe`	60	51
`press_stapler`	60	46
`put_bottles_dustbin`	9	9
`put_object_cabinet`	36	15
`rotate_qrcode`	82	33
`scan_object`	51	47
`shake_bottle`	98	91
`shake_bottle_horizontally`	98	93
`stack_blocks_three`	37	35
`stack_blocks_two`	77	75
`stack_bowls_three`	33	32
`stack_bowls_two`	81	53
`stamp_seal`	29	30
`turn_switch`	33	28

Caveats: single seed, and 100 episodes per task is roughly +/-5 points at 50%, so per-task deltas under about 10 points are not individually resolvable. Only the final epoch was evaluated; the earlier epochs were not.

Use

Install the plugin, then any lerobot CLI understands the policy type (griffin_alpha):

pip install git+https://github.com/griffinlabs-ai/alpha-s.git

import lerobot_policy_griffin_alpha  # registers the policy types
from lerobot.policies.factory import make_pre_post_processors
from lerobot_policy_griffin_alpha import GriffinAlphaPolicy

policy = GriffinAlphaPolicy.from_pretrained("griffinlabs/griffin-alpha-s-robotwin")
preprocessor, postprocessor = make_pre_post_processors(
    policy.config, pretrained_path="griffinlabs/griffin-alpha-s-robotwin",
    preprocessor_overrides={"device_processor": {"device": "cuda"}},
)

The observation dict takes the three cameras as float CHW images in [0, 1], observation.state as the 14-D joint vector above, and the instruction under task; predict_action_chunk returns the 50-step chunk, and the postprocessor turns it back into absolute joint targets.

Fine-tune with lerobot-train --policy.path=griffinlabs/griffin-alpha-s-robotwin --dataset.repo_id=...; see docs/finetuning.md in the code repository, including how to rebuild the processors for a different robot or camera set.