Agentic Physical AI: The Open Skill Layer
Build the open, cross-vendor skill layer that turns any policy into a robot skill: it installs, checks the body's declared capabilities against what the skill needs, and holds every action inside a runtime envelope on-device. You implement capability negotiation, the runtime envelope, policy-agnostic skills, LeRobot composition, and a safe MCP tool (then author and ship your own. The runtime clamp is the floor, not the guarantee) a box constraint bolted around the policy; the guarantee that matters is a certificate on the action's own energy, baked in (see Energy First Architecture).
▶ Start the course ← All coursesWhere this sits, and what moves it.
Binding constraint · What a body can be asked to guarantee about itself. A skill layer is only as safe as the capabilities a machine can verifiably declare and the envelope it can enforce on-device.
Every robot skill was written against one robot. Portability was a porting effort, so the ecosystem's work did not compound -- a thousand labs solved the same problem a thousand times.
Capability negotiation plus an on-device envelope makes a skill portable without making it unsafe, and this course implements both. What is not settled is the standard: several contracts exist, none has won, and a contract with no adoption is a design document.
This converges when declared capability becomes measurable rather than asserted -- when a body can prove its torque limit rather than claim it. That turns the envelope from a promise into a physical bound, and it is the same move as a certificate you can check on the device.
Every hard thing was impossible until the constraint that made it impossible was named. How we read a frontier →
The contract
Why robots need a skill layer: negotiate capabilities and bound the runtime.
- L2Will this run on my robot?A skill declares what it needs and a robot declares what it has. When should the answer come back?Answer a skill's compatibility against a robot's capabilities, before anything moves.→
- L2The safety envelope lives in the runtimeA hijacked policy fires NaN, huge jumps, and out-of-range commands. If the safety envelope lives in the RUNTIME (not the policy), can the robot still be kept fully safe?Bound ANY policy, even a hijacked one, with a runtime that clamps every command.→
Policy-agnostic skills
One contract, any policy, and composing the LeRobot ecosystem.
- L2One contract, any policyYou swap an analytic policy for a learned one behind the same contract. What has to change?Swap an analytic policy for a learned one without touching the contract, envelope, or wire.→
- L2Compose LeRobot, one adapter, any checkpointOne adapter drives several LeRobot architectures with action chunking. When does it re-infer?Drive different LeRobot architectures through one `.select_action` adapter, with action chunking.→
The protocol and the standard
Expose a robot to an LLM safely, then author and ship a skill.
- L3MCP for robots, done rightYou expose a robot to a language model over a tool. Where does the safety envelope belong?Expose a robot to a language model over a tool that enforces the safety envelope in the protocol.→
- L3Capstone, author and ship a skillYou author a skill, validate it, gate it and run it. Which of those four is the one that makes it safe to publish?Write a skill contract, validate it, gate it, and run it inside its own safety envelope.→