The open skill layer for physical AI.
Models that drive robots are arriving fast, and the app stores that ship them are walled (one skill, one vendor's body. skillpack is the open answer: a skill is source you own) a policy, a typed contract, a capability manifest, a safety envelope, an eval, that installs, gates itself against your robot's declared capabilities before anything moves, and holds every action inside a runtime safety envelope. It composes the policies you already train; it rides the hardware you already have.
Three properties, one contract.
The layers below (the models, the datasets, the hardware drivers) are being built well by others. The missing seam is the one above them: the contract that turns a trained policy into a skill you can install, gate against a robot, and trust to run. That is the whole of skillpack.
Composes what you already trained
A skill names a policy: an analytic controller, or a real learned checkpoint. Swap a P-controller for a 450M vision-language-action model and the contract, the safety envelope, and the transport do not change. The policy is a detail, not the interface.
Checks your robot before it moves
Every skill carries a capability manifest: the morphology, degrees of freedom, actuation, and sensors it needs. Install it and the registry answers “will this run on my robot?” first, with reasons, so a skill your body cannot execute never gets the chance.
The envelope is in the runtime, not the policy
A skill proposes actions; the runtime clamps them, a per-tick velocity cap, a workspace clamp, non-finite rejection. So even a wrong, or hijacked, policy cannot exceed the envelope. That is what lets an open registry be a safe one.
Pick a robot. Watch it gate. Run it.
Below is the real contract running in your browser, no server, no hardware. Choose a body and the registry gates each skill against its capabilities before offering it. Install a compatible one and its policy drives the joints through the safety envelope out to real Feetech wire bytes. Then corrupt the policy, feed it garbage, and watch the envelope hold: the joints stay bounded, the packets stay valid.
The same contract as the command line: skillpack add arm-reach checks the skill against your robot and installs the source you own, or refuses, with reasons, if your body cannot run it.
A working kernel, verified without a robot.
This is a prototype, and an honest one. The format, the runtime, the capability negotiation, the safety envelope, and the command-line installer all exist and are verified end-to-end with no hardware, the physical actuators are the one thing a browser cannot prove.
LeRobot
A skill's policy resolves a LeRobot checkpoint and calls its standard interface. skillpack sits above the model layer, it does not replace it.
In-browser VLA
The reference skill swaps its baseline controller for a real 450M SmolVLA, the same on-device policies we release and run on the page.
Forge
Record a dataset, train a policy, stream it to real hardware, the authoring end of the same skill the registry then distributes.
Not a demo: a standard you can build on.
skillpack is Apache-2.0, with a versioned spec, JSON schemas, an SEP change process, and a path to a neutral foundation. It ships an embodiment-aware MCP profile, so a language model can drive a robot with the safety envelope enforced in the protocol, and a bridge that runs real LeRobot checkpoints. And it is taught.
↗ github.com/dcharlot-physicalai-bmi/skillpack
# install a skill as source, from anywhere
skillpack add arm-reach --registry https://physicalai-bmi.org/assets/skillpack
Agentic Physical AI
A six-lesson course: build capability negotiation, the safety envelope, policy-agnostic skills, LeRobot composition, and a safe MCP tool, then author and ship a skill of your own.
Robot MCP Profile
The same skills exposed over MCP, but every call carries the robot's capabilities and safety envelope, and the server enforces them. A hijacked model still gets a bounded trajectory and a safety report.
LeRobot bridge
A cross-language bridge drives a skill from an actual LeRobot policy process through its standard interface, while the runtime envelope, on this side, bounds it.