Hugging Face opens an agent-built app store for its Reachy Mini desk robot

On May 6, Hugging Face CEO Clem Delangue announced an agentic toolkit and app store for Reachy Mini, the small open-source desktop robot Hugging Face sells with Pollen Robotics, the French robot maker it bought in April 2025. The pitch is easy to state: you describe what you want the robot to do in plain English, and an AI agent writes the code, tests it, ships it to the robot through the Hugging Face Hub, and keeps iterating with you until it works.

The numbers in Delangue's post give a sense of scale. The store lists more than 200 apps from over 150 creators. Almost 3,000 robots went out to customers in the week before the announcement, taking the installed base to nearly 10,000, and Hugging Face says more than 1,000 more will ship in the next 30 days. The Robot Report quotes Delangue framing the moment around who gets to build robots: "As of today, they can be built by anyone."

(The cover photo shows Pollen's full-size Reachy humanoid, not the Mini.)

What Hugging Face announced

The release has three parts that work together.

• An app store. Every Reachy Mini app is an open-source repo on the Hugging Face Hub. Delangue's post describes the catalog as searchable, forkable and installable in one click. If you like an app, the suggested move is to duplicate its repo and ask an agent to change it.
• A simulator in the browser. Each app also runs in a browser-based simulator, so you can try the catalog, or test your own changes, without owning the hardware.
• Agent-ready documentation. The post suggests starting with Hugging Face's own ML Intern agent or any other coding agent, and pointing it at the SDK repository and docs. The repository carries an AGENTS.md file written for exactly that reader.

The suggested first prompt is modest: ask the agent to build an app that waves and says hello when someone walks into the room, using the GitHub code and the documentation as references.

The showcase user is Joel Cohen, a 78-year-old who runs CEO peer groups on Zoom and had no robotics or coding background. According to Delangue's post, Cohen built a voice-controlled co-facilitator that wakes on "Hey Reachy," has a named personality, four facilitation modes and a bank of more than 60 questions, and greets each of his 29 group members by name. Mid-session it can put a member on the hot seat, push back on a shallow answer or summarize the themes before closing. The Robot Report describes him as a retired marketing executive.

Other listed apps show the range: a cooking assistant, a language tutor, an "emotional damage" chess game, a phone-use detector, Red Light, Green Light, a Formula 1 commentator, a coding teacher, dance apps, blind tests and a robotic claw interface.

From lab robots to a desk companion

Expressive heads and programmable humanoids

Robots built to communicate rather than to lift things have a long research history. One landmark is Kismet, a robot head built at MIT in the 1990s that used movable ears, eyebrows, eyelids and lips to express emotion. It now sits in the MIT Museum. Reachy Mini follows the same idea with far fewer parts: its expressiveness comes from head motion and two animated antennas rather than a face.

France already has one widely used programmable robot. Nao, from the Paris company Aldebaran, first shipped in 2008 as a RoboCup edition and became a standard platform for robot soccer, teaching and research. Wikipedia reports that more than 13,000 Nao units were in use in over 70 countries as of 2024, and that developers program it with a graphical tool called Choregraphe. It is also a cautionary tale: Aldebaran changed owners twice and entered receivership in France in June 2025.

Reachy Mini's claimed base of nearly 10,000 units, about ten months after its launch, puts it in the same order of magnitude as Nao's lifetime figure, at a far lower price.

Pollen Robotics and the Hugging Face deal

Pollen Robotics was founded in Bordeaux in 2016 by Matthieu Lapeyre and Pierre Rouanet and had raised about €2.5 million before Hugging Face bought it in April 2025 for an undisclosed sum, TechCrunch reported. Its main product was Reachy, a full-size humanoid upper body on a stand, later made mobile and controllable through virtual reality. Hugging Face had already worked with Pollen on an open-source household robot under its LeRobot effort, and had built a robotics team led by Remi Cadene, formerly of Tesla's Optimus program.

Reachy Mini arrived three months later, in July 2025. Engadget reported launch prices of $299 for the Lite, which plugs into a Mac or Linux computer, and $449 for the wireless version with onboard compute and a battery. Both ship as kits. Nvidia CEO Jensen Huang later featured the robot at CES, as reviewer Jeff Geerling notes.

What the robot is

The head mechanism is the interesting part. A Stewart platform is a parallel mechanism in which six actuators work together to move a plate through all six degrees of freedom: three directions of travel and three rotations. Large versions move flight-simulator cockpits. In Reachy Mini a small version tilts, turns and shifts the head, which is how such a simple robot manages to look curious, sleepy or surprised.

The AGENTS.md file lists the joint limits that the SDK enforces: head pitch and roll of ±40°, head yaw of ±180°, body yaw of ±160°, and no more than 65° of difference between where the head and the body point. Values outside those ranges are clamped automatically, and gentle collisions with the body are described as safe.

How the agent workflow fits together

The most useful document in this release is not a press post but AGENTS.md, the guide the SDK repository addresses to coding agents. The version committed on April 29, a week before the launch, reads like a house style for an AI collaborator.

Rules for the agent

Before doing anything, the agent is told to look for an agents.local.md file holding the user's setup, such as which robot they own, and to create it on the first session. It should act as a teacher, explaining concepts and not assuming prior knowledge. And before writing any code it must create a plan.md that restates what the user wants, lists the technical approach and asks clarifying questions, then wait for answers. That last rule is a sensible guard against the most common failure of agent-written code, which is building the wrong thing quickly.

A skills/ folder holds deeper guides that the agent loads only when needed, covering topics such as control loops, safe torque, LLM integration, interaction patterns, testing and the REST API.

Two kinds of apps

The guide tells agents to default to a JavaScript web app unless the user needs on-robot Python.

• Web apps are static Hugging Face Spaces. The page signs the user in with Hugging Face OAuth, then reaches the robot over WebRTC through a central signaling server, so the person using it needs no local install and no network setup. The robot's camera and microphone stream to the browser, and the user's microphone can stream back to the robot's speaker. The SDK is a single JavaScript module loaded from a CDN and pinned to a release tag.
• Python apps run on the owner's machine or on the wireless robot's Compute Module, and are meant for control loops, heavy motion sequencing or offline use. Agents are told never to hand-build the folder structure and to use the reachy-mini-app-assistant create command instead.

Under both sits a daemon that exposes an HTTP and WebSocket API on port 8000, either on your computer for the Lite or on the robot for the wireless model. The guide also notes that, for now, only Python apps are discoverable this way, and says that will change in a future release.

For on-robot code, the Python SDK is compact. The docs show a head move as a few lines:

from reachy_mini import ReachyMini
from reachy_mini.utils import create_head_pose

with ReachyMini() as mini:
    mini.goto_target(head=create_head_pose(z=10, roll=15, degrees=True, mm=True), duration=1.0)

The guide recommends goto_target() for gestures lasting half a second or more and set_target() for real-time loops such as tracking at 10 Hz or faster.

Where the simulator falls short

The docs describe the simulator as a MuJoCo environment that needs no hardware. The agent guide is candid about its gaps: simulation cannot test camera features, and the wireless robot running code locally has limited compute, while streaming from a laptop costs some tracking quality.

Definition: a static Space is a Hugging Face Hub repository that serves plain HTML, CSS and JavaScript from a public URL. For Reachy Mini web apps, that URL is the product: anyone signed in to Hugging Face can open it on a phone and drive a robot they have access to.

The numbers

What early users and critics found

The most detailed independent account before the launch came from reviewer Jeff Geerling, who tested the $449 wireless model in February. He found the kit well documented and built it with his children in under two hours, below the docs' estimate. He also hit rough edges: an IPv6 name-resolution problem during setup, inconsistent behavior across computers and browsers, and a desktop app with no build for ARM Linux.

His sharpest criticism was about the cloud. The Conversation App, the most impressive demo, connects to OpenAI for real-time chat. Geerling says he stopped it quickly when his kids began sharing family details with it, and he argues the apps that show the robot's potential should run locally without an internet connection. He also notes that pricing an Nvidia DGX Spark alongside the robot, for heavier local AI work, takes the total from $449 to about $4,449.

Those points apply directly to an app store fed by agent-written code. A one-click install of community code is only as safe as the code, and an agent that wires in a cloud API will do it in a few lines. The fact that every app is open source helps, because you can read it first, but Delangue's post does not describe a review process for listings.

Key caveat: "open source" comes with an asterisk. The documentation lists the software under the Apache 2.0 license but the hardware design files under Creative Commons BY-SA-NC, a non-commercial license. If a hackathon prototype is meant to become a product built on modified Reachy hardware, read that license before you plan around it.

Risks and open questions

• Review. Two hundred apps from 150 creators is a small catalog, and the examples in the announcement are mostly games, tutors and demos. There is no stated vetting for code that can see and hear inside homes and offices.
• Privacy defaults. Apps that call cloud models should say so before they start listening. Geerling's experience suggests that is not yet the norm.
• Agent-written code. The plan.md step and the clamped joint limits reduce risk, but nobody should run agent code on a device with a camera and microphones without reading it.
• Platform durability. Aldebaran's path through two sales and a 2025 receivership is a reminder that hardware ecosystems depend on their makers. Reachy Mini's open software and published hardware files are the hedge.
• Scale. Nearly 10,000 robots is a meaningful base for hobby hardware, but it is still small for an app economy. Whether creators keep building depends on users, and users depend on apps.

What hackathon teams can do with it

A small expressive robot makes a demo stick, and this release removes several usual blockers.

• Start from the reference app. The guide's canonical example, webrtc_example, is a roughly 500-line web app with sign-in, a robot picker, video, sliders and sound presets. Fork it and trim instead of starting from a blank page.
• Let the agent plan first. Give your coding agent the repo and the docs, and insist on the plan.md step. It is a cheap way to keep a weekend project on track.
• Split the team. With the browser simulator, everyone can build and test while one person holds the physical robot. Plan a real-hardware run early, because the simulator cannot test the camera, a noisy venue or conference Wi-Fi.
• Design for phones. The guide tells agents to assume users open apps on a smartphone. Judges walking past your table will too.
• Use the antennas. They double as buttons, which gives you a no-screen interaction for free.
• Pin your SDK version. The guide recommends importing the JavaScript SDK at a fixed release tag, so an upstream change cannot break your demo on the day.
• Keep secrets out of the repo. For local development the guide suggests pasting a read-only Hugging Face token instead of using OAuth, and warns never to commit it. Your app is a public repo.

Practical tip: if your app sends audio or video to a hosted model, show that clearly in the interface and add a visible mute. It is the first thing a careful judge, or a parent, will ask about.

What to watch

As of May 7, the concrete near-term signals are the ones Hugging Face put numbers on: more than 1,000 additional robots due within 30 days, and whether the app count keeps pace with the installed base. The agent guide also promises a change so that apps other than Python ones can be discovered through the robot's daemon. And the open questions raised by early users, about local-first defaults, consent for cloud calls and some form of review for store listings, have no public answer yet. How Hugging Face handles them will matter more to the store's future than the next round of demo videos.

Sources

• Introducing the agentic robotics appstore for 10,000 Reachy Minis (Hugging Face, May 6, 2026)
• Hugging Face launches agentic toolkit for Reachy Mini (The Robot Report, May 7, 2026)
• Reachy Mini AGENTS.md, development guide for AI agents (GitHub, April 29, 2026 revision)
• Reachy Mini documentation (Hugging Face)
• You can now pre-order Hugging Face's Reachy Mini robots (Engadget, July 2025)
• Hugging Face buys a humanoid robotics startup (TechCrunch, April 2025)
• Testing Reachy Mini, Hugging Face's Pi powered robot (Jeff Geerling, February 2026)
• Nao (robot) (Wikipedia)