Latest / Embodied AI 101 / SkillPlug: Teaching Robot Policies to Reuse the Moves Between Tasks

Transcript

SkillPlug: Teaching Robot Policies to Reuse the Moves Between Tasks · Embodied AI 101

• SkillPlug: Teaching Robot Policies to Reuse the Moves Between Tasks. SkillPlug: Unsupervised Skill Mining for Few-Shot Adaptation in Robotic Manipulation • Zi-han Ding and Ziwei Wang • School of Electrical and Electronic Engineering, Nanyang Technological University, Singapore • IEEE Robotics and Automation Letters, Vol. 11, No. 8 • 2026. Most multitask robot policies know more than they can reuse. A policy trained to pick fruit, stack blocks, open drawers, and place cups has almost certainly learned recurring behavioral fragments: move toward an object, align the wrist, close the gripper, transport while maintaining a grasp, and release. Yet in a conventional end-to-end network, those fragments remain distributed across millions or billions of parameters. When the robot encounters a new task, there is no explicit interface for retrieving and recombining them. Fine-tuning therefore risks relearning useful motion structure from a tiny demonstration set. SkillPlug starts from a simple hypothesis: perhaps few-shot adaptation should be less about changing what a robot knows and more about learning how to route through what it already knows. The paper introduces a module that can be inserted between the representation backbone and action head of an existing visuomotor policy. During multitask imitation learning, this module mines a small library of continuous skill embeddings without requiring annotated skill boundaries or names. At adaptation time, the backbone and skill library remain fixed. Only a lightweight router and the action head are updated, turning adaptation into a problem of selecting, mixing, and calibrating previously learned behavioral primitives. The results are unusually large in several settings. Adding SkillPlug to ACT raises average success on seven DISCOVERSE training tasks by 45.1 percentage points and on four ten-demonstration adaptation tasks by 18.1 points. Adding it to OpenVLA-OFT raises five-demonstration cross-suite LIBERO performance by 38.3 points on average. A real-robot experiment reports a 28.5-point gain on three unseen tasks. Those numbers make SkillPlug worth examining closely. But the more interesting contribution is conceptual: it treats a learned skill library not as a separate hierarchical controller, symbolic program, or manually segmented option set, but as a reusable basis inside the representation space of an ordinary visuomotor policy. The paper in one minute. SkillPlug has four essential ingredients:. A small library of learned, continuous skill codes shared across all training tasks. A cross-attention interactor that combines each skill code with the current scene representation. A router that assigns soft weights to the resulting skill-conditioned features for each action chunk. Self-supervised regularizers designed to make the skills compact, behaviorally meaningful, and non-redundant. During multitask training, a separate action-only posterior branch helps shape the skills around trajectory structure rather than visual appearance. This branch is discarded after training. For a novel task, the skill bank and perception backbone are frozen, while the router and action head are fine-tuned on five or ten demonstrations. One terminology point matters from the outset. “Unsupervised” refers to skill discovery: the method does not require skill names, phase labels, or manually marked boundaries. The policy as a whole is still trained through supervised behavioral cloning on expert actions, and the problem formulation assumes task-labelled multitask demonstrations. SkillPlug is therefore unsupervised skill mining inside supervised imitation learning, not unsupervised robot learning in the broader sense. Why action chunking alone does not create reusable skills. Both backbones used in the paper already predict temporally extended action chunks. ACT, the compact backbone used for DISCOVERSE and the real robot, was introduced as a generative model over action sequences. Predicting several actions at once helps mitigate compounding error and variation in human demonstrations. It has become a widely used baseline because it can learn difficult contact-rich behaviors from comparatively small datasets. OpenVLA-OFT is a much larger and semantically richer system. Its optimized fine-tuning recipe modifies OpenVLA with parallel decoding, continuous action regression, action chunking, and an L1 imitation objective. In its own evaluation, the recipe substantially improved both LIBERO success and action-generation throughput relative to the original OpenVLA decoder. Action chunking gives both policies a temporal prior, but it does not necessarily expose shared structure across tasks. The model still receives an observation and emits actions through one large computation graph. A movement used in five tasks may exist internally, but it is not represented as an object that can be explicitly selected during adaptation. Earlier skill-learning systems address this in several ways. Some segment demonstrations using human annotations, language models, or phase labels. Others encode action sequences into discrete tokens or latent options. QueST, for example, learns a discrete codebook of temporally extended action abstractions and then trains a prior that predicts sequences of those skill tokens. Language-guided temporal variational inference uses an LLM-produced initial segmentation and then merges segments into reusable skills through hierarchical inference. These approaches create explicit temporal abstractions, but they generally require a more specialized policy architecture or an explicit segmentation-and-decoding pipeline. SkillPlug takes a lighter-weight route. It does not replace the base policy or tokenize the trajectory into a sequence of discrete options. Instead, it inserts a small continuous mixture layer immediately before action generation. That distinction is central to both its practicality and its limitations. What SkillPlug actually represents as a skill. Suppose a base policy consists of a scene-context encoder and an action head. The encoder maps the observation into a hidden representation. Normally, that representation would flow directly into the action head. SkillPlug intercepts it. The method maintains a library of (K) learnable vectors. Each vector is intended to become a behavioral code. The same library is shared across every task in the multitask dataset and later reused for downstream adaptation. The vectors do not initially correspond to concepts such as “open gripper” or “move left.” Those semantics, when they emerge, are consequences of the imitation objective and the auxiliary regularizers. For every skill code, a shared skill interactor combines the code with the scene representation through cross-attention. This produces (K) candidate hidden features: what the current scene representation would look like when conditioned on each skill. A router then produces a soft distribution over those candidates. Routing occurs at the action-chunk level, so all actions in a predicted chunk share the same routing distribution. The weighted sum of the skill-conditioned features has the same dimensionality as the base policy representation and can therefore be passed into the original action head without redesigning that head. This makes SkillPlug more like a learned behavioral basis than a traditional option framework. A skill is not an independently executable closed-loop policy with initiation conditions and termination criteria. It is a continuous code that modulates a scene-dependent representation. Its behavioral meaning only exists through the interactor, router, and action head. That is why a skill can be both reusable and context-sensitive. A code associated with opening the gripper does not blindly emit a fixed motor command. It conditions the current scene feature in a way that causes the downstream action head to produce an opening motion appropriate to that scene and robot state. It also explains the paper’s compositionality claim. Since routing uses soft weights, two skill-conditioned features can be blended. In one intervention, a code that opens the gripper and a code that moves the end effector forward are assigned equal weight. The resulting policy moves forward while opening the gripper. This is composition in representation space rather than sequential composition of standalone controllers. The training-only trajectory posterior. If all components were trained only through action reconstruction, the skill library might not become useful. Different codes could collapse onto the same behavior, specialize to particular backgrounds, or simply become arbitrary extra capacity. SkillPlug therefore introduces a training-only, VAE-style trajectory–skill posterior. It projects a demonstrated action chunk into a trajectory feature and combines that feature with each skill embedding to form a skill-specific latent distribution. Importantly, this posterior sees actions but not images. Its purpose is to encourage the skill bank to reflect recurring trajectory structure rather than memorize scene appearance. This posterior is not required at deployment. Once multitask training is complete, the posterior branch is removed and the deterministic skill embeddings are used directly. The resulting policy therefore does not need access to future demonstrated actions at inference time. There is an appealing information-design principle here. Perception remains responsible for identifying the current situation. The action-only posterior shapes the reusable behavioral vocabulary. The router connects the two by deciding which elements of that vocabulary matter in the present context. Four objectives shape the library. SkillPlug is trained with four losses. Their roles are easier to understand as competing pressures on the representation than as equations. Faithful imitation. The first objective is ordinary behavior cloning. The predicted action chunk is compared with the demonstrated chunk using element-wise L1 error. This ensures that whatever abstractions emerge must still support accurate low-level control. Reconstruction alone, however, only asks the whole network to reproduce actions. It does not care whether the skill codes are compact, distinct, or transferable. Compactness through a KL bottleneck. The trajectory–skill posterior is regularized toward a standard prior. This limits how much trajectory-specific information can pass through each latent and discourages the skill representation from becoming a lookup table for individual demonstrations. Because the posterior receives actions rather than observations, the intended effect is to preserve recurring motion structure while discarding scene-specific detail. This is a familiar variational argument: if capacity is constrained, the representation must retain regularities shared by many samples rather than every incidental detail. Behavioral skill alignment. Compactness does not guarantee useful semantics. A compressed code can still be unrelated to the behavior the router associates with it. The behavioral skill alignment loss projects trajectory features and skill embeddings into a common space and scores their compatibility through an inner product. The router’s soft assignment over skills is treated as a target distribution for classifying the trajectory. If the router relies heavily on one skill while reconstructing a motion segment, the corresponding skill code is encouraged to become compatible with that segment’s action pattern. The authors stop gradients through the router for this objective. That choice is important. Without it, the router and skill representations could co-adapt in a circular way, changing their assignments merely to minimize the alignment loss. With stop-gradient, the router learns only through action reconstruction, while the alignment objective reshapes the skill library around the router’s behaviorally necessary assignments. Conceptually, this resembles a soft, implicit clustering loop. Reconstruction discovers which mixtures are useful for control; alignment makes the underlying codes reflect the action patterns those mixtures explain. Skill disentanglement. Even compact and behaviorally aligned codes can be redundant. SkillPlug therefore compares the actual features generated by different skills under the same observation. For each skill, its interactor outputs are averaged over time and normalized. The method then penalizes off-diagonal cosine similarity between different skills. Two skill embeddings are considered redundant not simply when the vectors themselves are close, but when they induce similar skill-conditioned features in context. That is a meaningful design choice. Orthogonal embeddings can still implement the same function after passing through a neural network. Penalizing the outputs of the interactor is closer to functional diversity, although the paper later also visualizes raw embedding similarities as a diagnostic. The complete objective combines reconstruction, KL regularization, behavioral alignment, and skill disentanglement with scalar weights. Few-shot learning becomes rerouting plus calibration. After multitask training, SkillPlug freezes the perception backbone and learned skill codes. The training-only posterior is discarded. For each unseen task, only the router and action head are fine-tuned. The intended interpretation is that the router learns how to recombine known primitives while the action head calibrates the fused representation for the new task. This is more constrained than full end-to-end fine-tuning and should reduce overfitting when demonstrations are scarce. It is not, however, pure zero-shot skill composition. Updating the action head gives the system some ability to learn new low-level mappings. The experimental evidence shows that a frozen skill library is useful, but it does not establish that all novel behavior is produced by routing alone. For the vanilla baselines, the paper freezes the backbone under the same adaptation protocol and fine-tunes only the action head. SkillPlug therefore has one additional trainable component—the router—during adaptation. That is a reasonable operational comparison, but a parameter-matched adapter baseline would be needed to fully separate reusable skill structure from the benefit of extra adaptable capacity. Experimental design. The evaluation uses two simulation benchmarks and a separate real-robot platform. DISCOVERSE with ACT. DISCOVERSE combines Gaussian-splatting-based visual reconstruction with MuJoCo physics and is designed for high-fidelity Real2Sim2Real robot learning. SkillPlug uses it primarily as a diverse simulation manipulation benchmark rather than as a direct simulation-to-real transfer experiment. The authors train one ACT policy on seven tasks, with 300 demonstrations per task and no explicit language conditioning. The action chunk contains 25 steps. Training runs for 6,000 epochs with a batch size of 16, a learning rate of (10^{-4}), and four learned skills. Four unseen tasks are then adapted separately from the multitask checkpoint using ten demonstrations each. Every task is evaluated over 50 trials, and the main results are averaged over three training seeds. LIBERO with OpenVLA-OFT. LIBERO was introduced to study the transfer of declarative and procedural knowledge in lifelong robot learning. Its task collection covers object, spatial, goal, and longer-horizon variations, with human-teleoperated demonstrations. SkillPlug trains one OpenVLA-OFT policy per reported suite, using eight skill embeddings and the base method’s default hyperparameters. For adaptation, the model is pretrained on LIBERO-Long and fine-tuned on LIBERO-Object, LIBERO-Goal, and LIBERO-Spatial using five demonstrations per task. Each suite receives 500 evaluation trials—50 per task. Real robot. The physical setup consists of a Galaxea A1 six-degree-of-freedom arm, a parallel gripper, a wrist-mounted RealSense D435i, and an external RealSense L515. ACT and ACT+SkillPlug are trained on six contact-rich tasks, then adapted to three unseen tasks using five demonstrations each. Results are reported as successes out of 20 trials per task. This is a separate real-world train-then-adapt study; the simulation-trained skill bank is not transferred directly to the physical robot. The headline results. The following averages summarize the central comparisons. Values should not be compared across benchmarks because the tasks, trial counts, backbones, and demonstration budgets differ. | Evaluation | Base policy | With SkillPlug | Absolute gain | |---|---:|---:|---:| | DISCOVERSE, seven training tasks | 41.0% | 86.1% | +45.1 points | | DISCOVERSE, four unseen ten-demo tasks | 29.7% | 47.8% | +18.1 points | | LIBERO, three unseen five-demo suites | 44.9% | 83.2% | +38.3 points | | Real robot, three unseen five-demo tasks | 30.0% | 58.5% | +28.5 points |. These averages are derived from the paper’s per-task results; the reported simulation numbers use three training seeds for the full systems. DISCOVERSE: the gains concentrate on hard behaviors. Vanilla ACT is highly uneven across the seven training tasks. It already reaches 99.3% on kiwi placement and 93.3% on coffee-cup placement, but achieves only 6.7% on jujube picking, 15.3% on block stacking, 0.7% on block-bridge placement, and no successes on drawer opening. SkillPlug raises those four difficult tasks to 94.0%, 80.7%, 36.7%, and 100%, respectively. It preserves or slightly improves performance on the easier tasks. The drawer result—zero to perfect success—is especially striking. It suggests that the compact ACT model was not simply missing visual information. Rather, its ordinary multitask parameterization failed to organize the available demonstrations into a control representation that covered all tasks effectively. On the four unseen tasks, ten-demo adaptation improves cup-lid covering from 0.7% to 18.7%, block placement from 36.0% to 56.0%, jujube placement from zero to 29.3%, and mouse pushing from 82.0% to 87.3%. SkillPlug does not solve every hard adaptation task, but it consistently moves performance in the right direction. LIBERO: little change when fully trained, large gains when data is scarce. OpenVLA-OFT is already near saturation in the multitask setting. Its success ranges from 92.9% to 97.6% across the four suites. SkillPlug changes these results only slightly: Long, Object, and Goal rise by less than one percentage point, while Spatial falls from 96.4% to 95.6%. That near-neutral result is useful. It indicates that adding the skill bottleneck does not require sacrificing a strong base policy’s well-trained behavior. The few-shot results are much more dramatic. When adapting from LIBERO-Long with five demonstrations per target task, OpenVLA-OFT obtains 47.4% on Object, 45.4% on Goal, and 42.0% on Spatial. SkillPlug reaches 79.6%, 83.2%, and 86.8%. The largest improvement is on Spatial, where success more than doubles. This is arguably the paper’s most important result. The module helps not only a small ACT policy but also a large pretrained VLA equipped with an already strong action-chunking fine-tuning recipe. That supports—though does not conclusively prove—the architecture-agnostic claim. Real-world adaptation. On the six seen physical tasks, ACT averages 9.7 successes out of 20 per task. ACT+SkillPlug averages 15.7. On the three unseen tasks, the average rises from 6.0 to 11.7 successes. Standing a cup improves from 3 to 12 successes, while placing a banana and bread onto a plate improves from 4 to 9. The router also shows repeated structure during the two pick-and-place phases of the banana-and-bread task. One skill dominates arm movement, another peaks around gripper transitions, and a fourth briefly activates during the wrist rotation needed to grasp the bread. This repetition across two object transfers is consistent with reuse rather than simple memorization of one monolithic trajectory. The physical study remains small—nine total tasks and 20 trials per task—but it confirms that the mechanism survives camera noise, contact variability, and real actuation errors. What the ablations reveal. The progressive ablation begins with reconstruction-only SkillPlug, then adds KL regularization, skill disentanglement, and finally behavioral alignment. On DISCOVERSE multitask training, average success progresses from 63.7% to 68.6%, then 83.7%, and finally 86.1%. Few-shot success progresses from 27.5% to 36.0%, then 41.0%, and finally 47.8%. The largest multitask jump comes from skill disentanglement. This supports the idea that the primary failure mode is not merely excessive information capacity but redundancy: without explicit pressure, multiple skill codes learn similar transformations. Behavioral alignment supplies a smaller final improvement in multitask performance but a substantial few-shot increase, from 41.0% to 47.8%. That pattern is consistent with alignment making the codes more transferable rather than merely increasing training-set capacity. These conclusions should be treated as suggestive rather than definitive. The ablation is progressive, so behavioral alignment is tested only after the other losses are present. Moreover, all ablated variants are single-seed diagnostics, while only the full objective’s average is reported over three seeds. The experiment does not measure every loss independently or every interaction between losses. Do the learned codes behave like skills?. The paper provides several interventions beyond aggregate success rates. First, the authors force the router to select one fixed skill across visually different scenes. The selected code repeatedly produces an open-gripper motion despite changes in objects, backgrounds, and viewpoints. This offers direct evidence that at least some codes capture behavior rather than acting as scene identifiers. Second, they manually combine two skills. Selecting one produces gripper opening; selecting the other produces forward motion; equally mixing them produces both simultaneously. This is stronger evidence than a t-SNE plot because it intervenes causally on the routing weights and observes the resulting behavior. Third, routing during a kiwi-placement episode is phase-structured. An open-gripper skill is active during approach, a rightward-motion skill changes around grasping, and a leftward-motion skill dominates transport toward the bowl. No interpretability loss explicitly supervises these phases; they emerge through reconstruction and the structure imposed on the skill bank. Finally, the authors vary the number of skills. Two skills produce an average success of roughly 76%, four produce 88%, and six produce 90% in a single-seed DISCOVERSE experiment. Embedding similarities and routing traces show increasing redundancy as the library grows. Despite seven training tasks, redundancy is already visible with six skills, suggesting the codes are not simply disguised task IDs. Most of the useful behavioral basis appears to fit into a smaller vocabulary. This result also exposes a practical hyperparameter problem: (K) must be selected manually. Too little capacity prevents adequate coverage, while too much capacity creates duplicate behaviors. The inference-efficiency claim needs careful wording. With the action-chunk size held fixed, ACT+SkillPlug requires fewer policy calls per successful DISCOVERSE episode on all seven tasks. Block stacking falls from 126 to 86 inference steps, and block-bridge placement from 181 to 119. The paper interprets this as evidence that the skill library supplies a stronger temporal prior and enables more efficient trajectories. That is plausible, but the metric counts decision steps rather than total compute. Each SkillPlug decision must produce several skill-conditioned features and route over them, so one policy call may be more expensive than one ACT call. Without wall-clock latency, FLOPs, or memory measurements, the experiment establishes behavioral step efficiency, not necessarily lower computational cost. What the paper convincingly establishes. The strongest claim supported by the evidence is narrow but meaningful:. Adding an explicitly regularized, shared skill-conditioning layer can substantially improve few-shot adaptation over the same underlying visuomotor backbone. That result holds for a compact ACT policy, a seven-billion-parameter-family VLA backbone, simulation tasks, and a small physical-robot study. The especially large LIBERO transfer gains suggest that even strong pretrained visual and linguistic representations do not automatically produce the procedural modularity needed for efficient control adaptation. The qualitative analysis is also better than the usual latent-space visualization. Fixed-routing and mixed-routing interventions demonstrate that changing the proposed skill variables produces interpretable changes in behavior. Although the semantics are not guaranteed to remain consistent across seeds or datasets, the intervention provides evidence that the codes are functionally meaningful. Another strength is that the regularizers directly target plausible failure modes. The KL term limits memorization, behavioral alignment ties codes to action structure, and output-level disentanglement attacks functional collapse. The ablation results support the importance of those choices, particularly the diversity objective. What remains unresolved. The evaluation compares each backbone mainly against itself with SkillPlug added. It does not include direct comparisons with specialized skill-learning systems such as QueST, Primitive Prompt Learning, SPECI, temporal variational inference, or mixture-of-experts skill policies. SkillPlug therefore wins a strong architectural ablation, but the paper does not establish that it is the best available method for skill discovery or few-shot manipulation. The adaptation comparison is not parameter-matched. SkillPlug updates its router and action head, while the vanilla baseline updates only its action head. A stronger control would add a similarly sized generic adapter to the baseline, or compare against LoRA and full fine-tuning under matched compute and validation procedures. The action head remains trainable, making attribution difficult. Some downstream behavior may be learned in the head rather than produced through pure recombination. Experiments that freeze the action head, randomize the skill bank, or exchange libraries between tasks would help isolate the source of transfer. SkillPlug also does not discover variable-duration temporal options or phase boundaries. Routing is attached to fixed action chunks. For planning, long-horizon credit assignment, or hierarchical reinforcement learning, additional machinery would be needed to model skill duration, preconditions, effects, and termination. The experiments remain within the same embodiment and action interface. A frozen library is most likely to help when new tasks can genuinely be constructed from motions and contact patterns present during pretraining. A new tool, gripper, force regime, or dexterous contact mode may require a primitive that does not exist in the bank. The authors identify this directly: the fixed library may hinder adaptation when novel tasks require new primitives, motivating expandable libraries for continual and cross-embodiment learning. Statistically, the main simulation results use three training seeds, but the loss and skill-count diagnostics are mostly single-seed. The real-robot study reports counts over 20 trials without confidence intervals. These are reasonable first results for an eight-page RA-L paper, but larger physical evaluations would be needed to characterize reliability. There are also reproducibility gaps in the public version. The paper defines scalar weights for the auxiliary objectives but does not spell out their values in the main text, nor does it fully enumerate module dimensions, router construction, parameter overhead, or training-time cost. As of August 1, 2026, the public arXiv and author publication listings point to the paper but do not advertise an official code release. How SkillPlug relates to nearby approaches. QueST is perhaps the closest conceptual neighbor. It learns discrete skill tokens by compressing one- to two-second action segments and then trains a policy to predict sequences of those tokens. Its discrete codebook provides a strong temporal abstraction, but it is a more substantial replacement for an ordinary action decoder. SkillPlug instead uses a small continuous library, soft composition, and an insertion point inside an existing policy. Temporal variational inference methods jointly infer reusable options and higher-level usage from demonstrations. The language-guided version adds LLM-based trajectory segmentation and a minimum-description-length objective to balance compression and reuse. SkillPlug avoids language-based segmentation entirely and focuses on fixed-length manipulation chunks, sacrificing explicit temporal hierarchy for architectural simplicity. Primitive Prompt Learning learns motion-aware prompts during multitask pretraining and adds new prompts during lifelong learning. SPECI similarly uses an expandable skill codebook and attention-driven selection for continual imitation learning. Both are more explicitly designed for ongoing library growth, whereas SkillPlug freezes its bank and optimizes rapid specialization to one new task at a time. These differences suggest a useful synthesis. SkillPlug offers an effective plug-in interface and strong self-supervised shaping losses. Continual-learning methods offer mechanisms for detecting when the existing vocabulary is insufficient and allocating new primitives. Combining those capabilities would address the paper’s largest structural limitation. Practical implications for roboticists. SkillPlug appears best suited to domains where tasks vary semantically but share a compact set of physical operations: tabletop sorting, kitchen manipulation, packing, machine tending, and assembly families built from recurring approach, grasp, insertion, rotation, transport, and release patterns. The pretraining dataset must contain genuine procedural overlap. More visual diversity alone will not teach a missing contact primitive. If the downstream task requires levering, tool use, deformable manipulation, or force-controlled insertion absent from the source demonstrations, a frozen library may become a constraint rather than a prior. For teams adapting this idea, five practical lessons follow:. Insert the module near action generation. The representation should be rich enough to contain scene context but close enough to the action head that skill conditioning has a direct behavioral effect. Use action-only supervision to shape procedural structure. Preventing the skill-mining branch from seeing images reduces the opportunity to encode object identity or background shortcuts. Monitor functional redundancy. Compare skill-conditioned outputs and router usage, not just distances between the code vectors. Keep the initial library small. The DISCOVERSE study shows diminishing returns and visible duplication as (K) grows. Evaluate against parameter-matched adapters. This is essential for determining whether a new implementation gains from procedural structure or merely from additional trainable parameters. A natural extension would make the bank expandable. A novelty detector could identify trajectories poorly reconstructed by every existing skill, allocate a new code, and regularize that code against the established library. Sparse routing or load-balancing objectives could then prevent old and new skills from collapsing together. Cross-embodiment transfer would require a further separation between abstract procedural intent and embodiment-specific execution. One possibility is a shared skill bank paired with separate action decoders for each robot. The router could preserve concepts such as approach, transport, or release, while each embodiment-specific head maps those concepts into its own joint and gripper space. For VLA systems, SkillPlug also suggests that parameter-efficient adaptation need not be limited to LoRA or prompt tuning. A procedural adapter between semantic perception and action decoding may be better aligned with what changes between manipulation tasks. The large LIBERO gains make that direction particularly compelling, although broader validation across diffusion, flow-matching, and autoregressive action heads is still needed. Final assessment. SkillPlug is not a complete hierarchical skill-learning system, and its learned codes should not be mistaken for symbolic actions or autonomous options. They are continuous, scene-conditioned basis elements inside a visuomotor policy. Within that scope, the paper delivers a clear result: explicit behavioral structure can matter even when the underlying model is already large, pretrained, and action-chunked. The robot does not necessarily need to rewrite its entire policy for every new task. It may only need a better vocabulary of reusable motions and a lightweight mechanism for recomposing them. The most enduring idea in SkillPlug is therefore not any individual loss. It is the reframing of few-shot robot adaptation as learning a new route through an existing procedural basis. The experiments make a persuasive case that this route can be dramatically more data-efficient than asking an end-to-end policy to rediscover its own latent skills from scratch.