Subscribe
0%
Illustration for: MIT's PEAR trains an open 27B reasoning model to drive real robot arms with no demonstrations. What the results show

MIT's PEAR trains an open 27B reasoning model to drive real robot arms with no demonstrations. What the results show

Song Han's lab at MIT has released PEAR, an Apache-2.0 training engine that teaches Qwen3.8-27B to control robots purely through reinforcement learning in simulation. The model lifts LIBERO success from 1.6% to 74.4% and succeeds in 18 of 30 trials on a real dual-arm robot it never saw, but each move takes seconds of thinking.

Listen to this article0:00 / 5:16
mit-han-lab/pear

Post-training engine that teaches an open reasoning model to use real robots via RL in simulation, without demonstrations

License
Apache-2.0
Try it
git clone https://github.com/mit-han-lab/pear.git && cd pear && bash scripts/install.sh libero_run
View on GitHub

MIT's Han Lab has open-sourced PEAR, a training engine that turns an off-the-shelf open-weight reasoning model into a robot controller using only reinforcement learning in simulation. It uses no human teleoperation demonstrations, no real-robot data and no separate perception or grasp-planning module. The paper, posted to arXiv on November 13 by 11 authors including Song Han, reports that the trained Qwen3.8-27B model succeeded in 18 of 30 trials (60%) on a real dual-arm robot it had never seen. The untrained base model succeeded in none. The Apache-2.0 code is on GitHub, and Chinese outlet Synced (via ifeng) brought it to a wider audience on November 15.

Why it matters: "robot-use" agents, which look at camera frames and decide the next move the way computer-use agents click through screens, have mostly worked well only with closed frontier models. PEAR is an attempt to make an open 27B model competitive on a single consumer GPU. The paper is also candid about where the approach is still weak.

How it works

At each turn the model sees the camera images, reasons step by step, and outputs one target pose for the robot's gripper (position plus roll, pitch and yaw). Inverse kinematics and a low-level controller carry out the move, and the new frames go back to the model. The authors call the method robot-use reinforcement learning (RURL).

Training ran 225 RL steps on the LIBERO simulator, then 115 more on two tasks in the dual-arm RoboDojo simulator. According to the full text, it uses GRPO-style group-normalised rewards, 128 groups of 8 rollouts per step, and fully asynchronous rollouts built on veRL and LMCache. The paper doesn't state the number of training GPUs in the sections we could read.

The numbers (as reported by the authors)

Benchmark PEAR (Qwen3.8-27B) Base model Comparison
LIBERO (2,000 episodes) 74.4% 1.6% GPT-6 Astra 49.3% medium / 80.6% max; GPT-6.1 Sol 48.1% / 76.2%; π0.5 96.9%
LIBERO-Pro, new task in familiar scene 57.4% — π0.5 0.75%
LIBERO-Pro, swapped object positions 57.5% — π0.5 20.8%
LIBERO-Long (not trained on) 39.0% 0.4% —
RoboLab-120 (zero-shot, 1,200 episodes) 37.3% 5.4% Cosmos3-Nano-Policy 36.8%, π0.5 28.0%, GR00T N1.6 7.2%
Real dual-arm YAM robot (30 trials) 18/30 0/30 LIBERO-only checkpoint 7/30

Two caveats. First, π0.5, a vision-language-action model fine-tuned on demonstrations, still wins clearly on standard LIBERO. PEAR's case rests on robustness: it holds up when the task or layout changes, where π0.5 collapses. Second, the frontier-model comparisons are the authors' own runs. Synced's write-up lists the GPT-6 Astra and GPT-6.1 Sol maximum-effort scores the other way round from the paper; we've used the paper's attribution.

The real-robot test used two kinds of task: aligning blocks against a triangle ruler (10 trials) and picking up ten kinds of object (20 trials). The authors say the model also kept its general skills, staying within the base model's confidence intervals on nine reasoning, coding and vision benchmarks.

Speed is the catch

At the "xhigh" effort used for the headline results, the model thinks about 3,230 tokens per move, and each action round takes about 4.3 seconds even on an Nvidia GB300, the paper says. Successful real-robot trials took 7 to 24 rounds. At low effort a round drops to about 1.1 seconds, but LIBERO success falls to 21.9%. Reported decoding speeds with NVFP4 weights and a speculative drafter are 221 tokens/s on a single RTX 5090, 747 on a GB300 and 52 on an Apple M5 Max. However, the evaluations themselves used BF16 weights because NVFP4 hurt accuracy.

The authors list other limits too: training stopped early because of GPU limits; harder tasks needed detailed prompts describing the robot; and the model can't yet plan multi-step action chunks, so complex motions are slow and depend on the quality of the controller.

What's in the repo

According to the GitHub page, the release includes the training engine, evaluation harnesses for LIBERO, LIBERO-Plus, LIBERO-Pro, RoboDojo and RoboLab-120, a vLLM model server, and a "robot station" that drives YAM or SO-101 arms. Training is meant for multi-GPU Nvidia Blackwell or Hopper nodes with shared storage. The model server runs on one RTX 5090 or GB300. Trained weights aren't in the repo itself; the page links to a Hugging Face collection, which we didn't inspect.

git clone https://github.com/mit-han-lab/pear.git && cd pear
export WORK_DIR=<shared directory>
bash scripts/install.sh libero_run

Who should care

Robotics researchers and hobbyists with an SO-101 arm and an RTX 5090 now have an open, end-to-end recipe to test against VLA models like π0.5. The headline 60% is from 30 trials on two task types, so treat it as a proof of concept, not a reliability figure. What to watch: independent replications on other robots, and whether a length penalty or action chunking can bring the multi-second think time per move down.

Sources

  1. arXiv — Training Reasoning Models in Simulation to Natively Use Real Robots (2611.18562) arxiv.org
  2. arXiv — Training Reasoning Models in Simulation to Natively Use Real Robots (HTML full text) arxiv.org
  3. GitHub — mit-han-lab/pear github.com
  4. ifeng Tech (Synced) — Han Song's team gets Qwen3.8-27B to operate robot arms on a 5090, now open source tech.ifeng.com

#MIT#Song Han#PEAR#robotics#reinforcement learning#Qwen#open source#LIBERO#robot-use agents