Hugging Face to Sell Open-Source Robots: Inside the Pollen Robotics Acquisition

The AI landscape has a new frontier, and it’s not just in the cloud. Hugging Face, the platform synonymous with open-source machine learning models, has made a bold move into the physical world. By acquiring Pollen Robotics, a French startup known for its open-source humanoid robot Reachy, Hugging Face signals its intent to sell robots directly to developers and researchers. This is not merely an acquisition of technology—it’s a strategic bet that the future of embodied AI will be built on open standards, just like the transformers and diffusion models that revolutionized software AI.

For anyone who has followed the rapid evolution of large language models (LLMs) and vision transformers, this news feels both surprising and inevitable. Hugging Face has long been the GitHub of machine learning, hosting over 500,000 models and 250,000 datasets as of mid-2026. Now, they are extending that ecosystem to include hardware. The acquisition of Pollen Robotics gives Hugging Face immediate access to a production-ready, open-source robot platform that can serve as a testbed for the next generation of autonomous agents.

In this article, we’ll dissect what the acquisition means, why open-source hardware matters for AI research, and how you—as a developer or researcher—can already start building with Reachy and the Hugging Face ecosystem. We'll walk through concrete steps to integrate a Pollen Robotics robot with Hugging Face models, write code to control it via a transformer-based policy, and explore the implications for the broader robotics community.

Source

The Strategic Rationale: Why Open-Source Hardware Now?

Hugging Face’s mission has always been to democratize good AI. Until now, that meant democratizing software—models, datasets, and training pipelines. But AI is increasingly embodied. Autonomous driving, warehouse robots, and domestic assistants all require a bridge between digital intelligence and physical action.

Pollen Robotics’ Reachy is a perfect entry point. It’s a humanoid upper-body robot with 7 degrees of freedom per arm, a flexible neck, and an expressive face. Crucially, its hardware design files are open-source under a Creative Commons license, and its control software is built on ROS 2 (Robot Operating System 2). This aligns perfectly with Hugging Face’s philosophy: share the blueprints, let the community iterate.

The acquisition gives Hugging Face the ability to sell Reachy robots directly to universities, research labs, and corporate R&D teams. According to the official announcement, the goal is to make Reachy “the standard platform for open-source embodied AI research.” This mirrors what Hugging Face did for NLP with the Transformers library—create a unified interface that works across many models.

What Changes for Developers and Researchers?

If you were already a user of Pollen Robotics products, the acquisition means more integration with the Hugging Face model hub. You can now expect:

• Pre-trained policies for manipulation tasks (e.g., pick-and-place, human-robot interaction) available as Hugging Face models.
• Direct Python bindings that allow you to load a model from the hub and deploy it on Reachy in minutes.
• Community datasets of robot demonstrations, shared on the Hugging Face Datasets library.
• A unified API for controlling Reachy, similar to how transformers provides a standard interface for text generation.

For newcomers, the barrier to entry drops significantly. Instead of building a robot from scratch or navigating proprietary SDKs, you can buy a Reachy (pricing expected to be competitive with other research robots like the Franka Emika Panda or Universal Robots UR5e) and immediately start experimenting with state-of-the-art AI.

Step-by-Step: Building an Open-Source Robot Agent with Reachy and Hugging Face

Let’s walk through a practical example. Suppose you want to train Reachy to pick up a small object from a table and place it in a bin. Traditionally, this would require writing a kinematic solver, hand-crafting waypoints, and tuning PID controllers. With the Hugging Face + Pollen Robotics ecosystem, you can leverage imitation learning or reinforcement learning directly.

Prerequisites

• A Reachy robot (or the simulation environment, which is also open-source)
• Python 3.10+
• ROS 2 Humble installed
• Hugging Face account and transformers library

Step 1: Set Up the Environment

First, install the Reachy Python SDK:

pip install reachy-sdk

Then, clone the Hugging Face integration repository (expected to be released post-acquisition, but for now use the community fork):

git clone https://github.com/pollen-robotics/reachy-huggingface.git
cd reachy-huggingface

Step 2: Load a Pre-Trained Policy from the Hub

Hugging Face will host models fine-tuned for Reachy. Imagine a model called polleny/reachy-pick-place-v1. You can load it like any other model:

from transformers import AutoModel
import torch

model = AutoModel.from_pretrained("polleny/reachy-pick-place-v1")
model.eval()

This model takes as input a camera image and the robot’s joint angles, and outputs target joint positions or end-effector velocities.

Step 3: Connect to Reachy

from reachy_sdk import ReachySDK

# Replace with your robot's IP
reachy = ReachySDK("192.168.1.100")

Step 4: Run the Inference Loop

import cv2
import numpy as np

while True:
    # Capture camera frame
    frame = reachy.right_camera.last_frame
    if frame is None:
        continue

    # Get current joint angles
    joint_states = reachy.r_arm.joint_positions

    # Preprocess for the model
    inputs = {
        "image": torch.tensor(frame).unsqueeze(0),
        "joints": torch.tensor(joint_states).unsqueeze(0)
    }

    # Inference
    with torch.no_grad():
        target_joints = model(**inputs).logits.squeeze(0).numpy()

    # Send commands to the arm
    reachy.r_arm.set_joint_positions(target_joints, duration=0.5)

This loop runs at about 10 Hz, which is sufficient for many manipulation tasks. For higher-frequency control, you can offload inference to an NVIDIA Jetson or a cloud GPU via Hugging Face Inference Endpoints.

Step 5: Log and Share Your Data

One of the most powerful aspects of this ecosystem is the ability to share your demonstration data. Use the Hugging Face Datasets library to upload trajectories:

from datasets import Dataset

# Assume you collected 1000 trajectories
data = {
    "images": [...],
    "joints": [...],
    "actions": [...]
}
dataset = Dataset.from_dict(data)
dataset.push_to_hub("your-username/reachy-pick-place-demo")

Now the entire community can use your data to train better policies.

Comparison: Reachy vs. Other Research Robots

To understand the significance of this acquisition, let’s compare Reachy with other common research platforms:

Reachy’s combination of open hardware, humanoid form, and direct Hugging Face integration makes it uniquely suited for research on human-robot interaction, manipulation, and embodied AI.

Implications for the Robotics Industry

Hugging Face’s entry into hardware sales could accelerate a trend that many have predicted: the commoditization of robot hardware. Just as cloud computing made servers a commodity, open-source hardware platforms could make robot bodies a commodity, shifting value to the AI software that controls them.

This has several consequences:

1. Lower barriers to entry: Small labs and startups can now afford a capable research robot. Previously, only well-funded institutions could buy a $50,000+ platform.
2. Faster iteration: With shared datasets and pre-trained models, the cycle time from idea to experiment shrinks from months to days.
3. Standardization: If Reachy becomes the de facto standard for open-source robotics research, it will be easier to reproduce and build upon others’ work.
4. AI-native robots: Instead of retrofitting AI onto existing industrial robots, Reachy is designed from the ground up to be controlled by neural networks.

Challenges and Open Questions

No acquisition is without risks. Hugging Face will need to handle hardware support, warranty, and supply chain—areas far from their core competency. They have stated they will work with Pollen Robotics’ existing manufacturing partners, but scaling hardware production is notoriously difficult.

Additionally, the robot market is crowded. Boston Dynamics, Tesla, and numerous startups are also pushing humanoid robots. Hugging Face’s advantage lies not in hardware prowess but in the community and software ecosystem. If they can make Reachy the “Arduino of robots,” they may succeed.

There is also the question of simulation. For large-scale training, researchers need high-fidelity simulators. Pollen Robotics supports Gazebo and MuJoCo, but Hugging Face may invest in a dedicated simulation platform integrated with their model hub.

How to Get Involved

If you’re excited about this development, here are concrete ways to start today:

1. Join the Hugging Face Robotics community – There’s a new #robotics channel on the Hugging Face Discord and a dedicated discussion forum.
2. Run the Reachy simulator – Even without physical hardware, you can run Reachy in simulation using Gazebo and test control policies.
3. Submit a model – If you train a policy for Reachy, upload it to the Hub with the tag reachy. The community will use it.
4. Pre-order a Reachy – Hugging Face has opened a waitlist for the first batch of robots. Expected shipping is Q3 2026.

Conclusion

The acquisition of Pollen Robotics by Hugging Face marks a pivotal moment in the convergence of open-source AI and robotics. For the first time, a major platform is not just hosting models for software AI but also selling the hardware to run them in the physical world. Reachy, with its humanoid form, open-source design, and deep Hugging Face integration, is poised to become the go-to platform for embodied AI research.

Whether you are a researcher working on robot learning, a developer building a home assistant, or a student eager to experiment with AI, this acquisition lowers the barriers and raises the possibilities. The robots are coming—and they are open-source.

Source