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.