EmbodiedSkills: A Unified Framework for Orchestrating, Training, and Deploying VLA Agents

TL;DR

EmbodiedSkills (Zhejiang + collaborators; Wang, Zhang et al.) frames each skill decision as an execution proposal rather than a committed action: a shared executable-skill interface sits between high-level skill selection, a bounded low-level VLA (Qwen3-VL + OpenPI / π0.5), and post-action verification, all inside a single agent loop. The runtime checks a skill’s prerequisites before execution and verifies the outcome after — so long-horizon behavior is closed-loop by construction and the low-level VLA can be swapped or adapted without touching the orchestration layer. Reports 86.20% average success across 50 RoboTwin 2.0 tasks, 97.40% across the four LIBERO suites, and 12.5% on four memory-dependent RMBench tasks with task-adapted low-level policies. The interface also records planning / execution / verification / recovery events as structured trajectories, positioned as the supervision substrate for optional online adaptation.

Key claims

VLA action prediction alone does not guarantee that a proposed operation is valid in the current physical state or that its outcome will be verified — long-horizon tasks require coordinated perception, planning, execution, verification, and recovery on top of the action head [Abstract].
Treating each skill decision as an execution proposal — with prerequisite checks before execution and outcome verification after — is the load-bearing framing that turns the VLA into a closed-loop component rather than an open-loop policy [Abstract].
A shared executable-skill interface connects high-level skill selection, bounded low-level VLA execution, and post-action verification within a single agent loop; because this interface stays fixed, the low-level VLA policy can be replaced or adapted without changing the agent loop [Abstract].
The interface records planning, execution, verification, and recovery events as structured trajectories, which the paper positions as supervision for individual components and as the substrate for optional online adaptation when interactive feedback is available [Abstract].
Task-adapted low-level VLA policies inside EmbodiedSkills reach 86.20% average success across 50 RoboTwin 2.0 tasks and 97.40% across the four LIBERO suites using Qwen3-VL as the high-level model and OpenPI / π0.5 as the low-level policy [Abstract].
On four memory-dependent RMBench tasks the same task-adapted execution approach reaches 12.5% average success — flagged as the current ceiling of this configuration on memory-heavy long-horizon tasks [Abstract].

Method

EmbodiedSkills is instantiated with Qwen3-VL as the high-level reasoning model and OpenPI / π0.5 as the low-level VLA policy. Each skill is exposed through a shared executable-skill interface with three phases inside a single agent loop: (1) prerequisite check — the runtime evaluates whether the proposed skill’s preconditions hold in the current observation before the low-level VLA is invoked; (2) bounded low-level VLA execution — the VLA runs against the current subgoal within an execution bound rather than open-endedly; (3) post-action verification — the runtime checks the intended outcome against the observation after execution and emits a structured event. Because the interface is fixed, swapping the low-level policy or adapting it per task does not require any change to the orchestration loop above it. Planning, execution, verification, and recovery events accumulate as structured trajectories over the fixed interface — the paper positions these as per-component supervision and as an optional online-adaptation substrate when interactive feedback is available, though the results below use task-adapted (not online-adapted) low-level policies. Code is at github.com/DCDmllm/EmbodiedSkills.

Results

RoboTwin 2.0 (50 tasks, task-adapted low-level VLA): 86.20% average success [Abstract].
LIBERO (four suites, task-adapted low-level VLA): 97.40% average success [Abstract].
RMBench (four memory-dependent tasks, same task-adapted execution approach): 12.5% average success [Abstract].
No head-to-head numbers vs a bare Qwen3-VL orchestrator, a bare π0.5, or against the closest sibling frameworks (Harness VLA: Steering Frozen VLAs into Reliable Manipulation Primitives via Memory-Guided Agents Harness VLA, Addressing the Orchestration Gap in Generalist Robots via Physical Agency (Pigey) Pigey) are visible from the abstract; a targeted refresh once the PDF body is parseable would clarify how much of the RoboTwin / LIBERO number comes from the interface vs the task adaptation of the low-level policy.
Ablation of the three interface phases (prerequisite check alone, verification alone, both) is not visible from the abstract.

Why it’s interesting

EmbodiedSkills is the next entry in the “wrap the frozen or task-adapted low-level VLA in a closed-loop orchestrator” cluster that this wiki has been actively tracking. It shares the recipe axis of Harness VLA: Steering Frozen VLAs into Reliable Manipulation Primitives via Memory-Guided Agents (Harness VLA exposes π0.5 as a narrow contact-rich primitive with an LLM planner handling staging + recovery around it) and Addressing the Orchestration Gap in Generalist Robots via Physical Agency (Pigey) (Pigey’s explicit observe → reason → act → verify → recover loop with π0.5 + TAMP as heterogeneous backends), but stakes out a distinct position on interface discipline: rather than a prompt-engineered guide file or a per-task tool taxonomy, every skill goes through the same executable-skill interface with prerequisite + verification hooks, which is what buys policy-swap and per-task adaptation without touching the loop. The RMBench number (12.5% on memory-dependent tasks) is the useful counter-signal on the concept-page’s VLA Models discussion of memory augmentation (RoboMemArena: A Comprehensive and Challenging Robotic Memory Benchmark PrediMem, BridgeVLA++: A Data-Efficient, Generalizable, and Memory-Augmented Vision-Language-Action Framework for 3D Manipulation BridgeVLA++, RoboTTT — 8k-timestep robot policy via test-time training (Jim Fan / NVIDIA GEAR) RoboTTT): a well-designed skill orchestration layer does not by itself solve the memory-dependent long-horizon regime, arguing memory has to be addressed lower in the stack.